fix: Fixes issue where lock screen would not use previously active theme

packages/features/src/Domain/Component/NoteType.spec.ts

@@ -1,16 +1,16 @@
-import { FeatureIdentifier } from '@standardnotes/features'
+import { NativeFeatureIdentifier } from '@standardnotes/features'
 import { noteTypeForEditorIdentifier, NoteType } from './NoteType'
 
 describe('note type', () => {
   it('should return the correct note type for editor identifier', () => {
-    expect(noteTypeForEditorIdentifier(FeatureIdentifier.PlainEditor)).toEqual(NoteType.Plain)
-    expect(noteTypeForEditorIdentifier(FeatureIdentifier.SuperEditor)).toEqual(NoteType.Super)
-    expect(noteTypeForEditorIdentifier(FeatureIdentifier.MarkdownProEditor)).toEqual(NoteType.Markdown)
-    expect(noteTypeForEditorIdentifier(FeatureIdentifier.PlusEditor)).toEqual(NoteType.RichText)
-    expect(noteTypeForEditorIdentifier(FeatureIdentifier.CodeEditor)).toEqual(NoteType.Code)
-    expect(noteTypeForEditorIdentifier(FeatureIdentifier.SheetsEditor)).toEqual(NoteType.Spreadsheet)
-    expect(noteTypeForEditorIdentifier(FeatureIdentifier.TaskEditor)).toEqual(NoteType.Task)
-    expect(noteTypeForEditorIdentifier(FeatureIdentifier.TokenVaultEditor)).toEqual(NoteType.Authentication)
+    expect(noteTypeForEditorIdentifier(NativeFeatureIdentifier.TYPES.PlainEditor)).toEqual(NoteType.Plain)
+    expect(noteTypeForEditorIdentifier(NativeFeatureIdentifier.TYPES.SuperEditor)).toEqual(NoteType.Super)
+    expect(noteTypeForEditorIdentifier(NativeFeatureIdentifier.TYPES.MarkdownProEditor)).toEqual(NoteType.Markdown)
+    expect(noteTypeForEditorIdentifier(NativeFeatureIdentifier.TYPES.PlusEditor)).toEqual(NoteType.RichText)
+    expect(noteTypeForEditorIdentifier(NativeFeatureIdentifier.TYPES.CodeEditor)).toEqual(NoteType.Code)
+    expect(noteTypeForEditorIdentifier(NativeFeatureIdentifier.TYPES.SheetsEditor)).toEqual(NoteType.Spreadsheet)
+    expect(noteTypeForEditorIdentifier(NativeFeatureIdentifier.TYPES.TaskEditor)).toEqual(NoteType.Task)
+    expect(noteTypeForEditorIdentifier(NativeFeatureIdentifier.TYPES.TokenVaultEditor)).toEqual(NoteType.Authentication)
     expect(noteTypeForEditorIdentifier('org.third.party')).toEqual(NoteType.Unknown)
   })
 })

packages/features/src/Domain/Component/NoteType.ts

@@ -1,8 +1,6 @@
 import { EditorFeatureDescription } from '../Feature/EditorFeatureDescription'
 import { FindNativeFeature } from '../Feature/Features'
 import { IframeComponentFeatureDescription } from '../Feature/IframeComponentFeatureDescription'
-import { FeatureIdentifier } from './../Feature/FeatureIdentifier'
-import { EditorIdentifier } from './EditorIdentifier'
 
 export enum NoteType {
   Authentication = 'authentication',
@@ -16,10 +14,8 @@ export enum NoteType {
   Unknown = 'unknown',
 }
 
-export function noteTypeForEditorIdentifier(identifier: EditorIdentifier): NoteType {
-  const feature = FindNativeFeature<EditorFeatureDescription | IframeComponentFeatureDescription>(
-    identifier as FeatureIdentifier,
-  )
+export function noteTypeForEditorIdentifier(identifier: string): NoteType {
+  const feature = FindNativeFeature<EditorFeatureDescription | IframeComponentFeatureDescription>(identifier)
   if (feature && feature.note_type) {
     return feature.note_type
   }

packages/features/src/Domain/Feature/BaseFeatureDescription.ts

@@ -1,5 +1,4 @@
 import { PermissionName } from '../Permission/PermissionName'
-import { FeatureIdentifier } from './FeatureIdentifier'
 import { ComponentFlag } from '../Component/ComponentFlag'
 import { RoleFields } from './RoleFields'
 
@@ -14,7 +13,7 @@ export type BaseFeatureDescription = RoleFields & {
   clientControlled?: boolean
 
   flags?: ComponentFlag[]
-  identifier: FeatureIdentifier
+  identifier: string
   marketing_url?: string
   name: string
   no_expire?: boolean

packages/features/src/Domain/Feature/ClientFeatureDescription.ts

@@ -1,9 +1,8 @@
 import { PermissionName } from '../Permission/PermissionName'
-import { FeatureIdentifier } from './FeatureIdentifier'
 import { RoleFields } from './RoleFields'
 
 export type ClientFeatureDescription = RoleFields & {
-  identifier: FeatureIdentifier
+  identifier: string
   permission_name: PermissionName
   description: string
   name: string

packages/features/src/Domain/Feature/Features.ts

@@ -1,7 +1,7 @@
 import { AnyFeatureDescription } from './AnyFeatureDescription'
 import { ThemeFeatureDescription } from './ThemeFeatureDescription'
 import { EditorFeatureDescription } from './EditorFeatureDescription'
-import { FeatureIdentifier } from './FeatureIdentifier'
+import { NativeFeatureIdentifier } from './NativeFeatureIdentifier'
 import { serverFeatures } from '../Lists/ServerFeatures'
 import { clientFeatures } from '../Lists/ClientFeatures'
 import { GetDeprecatedFeatures } from '../Lists/DeprecatedFeatures'
@@ -23,11 +23,11 @@ export function GetFeatures(): AnyFeatureDescription[] {
   ]
 }
 
-export function FindNativeFeature<T extends AnyFeatureDescription>(identifier: FeatureIdentifier): T | undefined {
+export function FindNativeFeature<T extends AnyFeatureDescription>(identifier: string): T | undefined {
   return GetFeatures().find((f) => f.identifier === identifier) as T
 }
 
-export function FindNativeTheme(identifier: FeatureIdentifier): ThemeFeatureDescription | undefined {
+export function FindNativeTheme(identifier: string): ThemeFeatureDescription | undefined {
   return themes().find((t) => t.identifier === identifier)
 }
 
@@ -40,17 +40,17 @@ export function GetIframeEditors(): IframeComponentFeatureDescription[] {
 }
 
 export function GetSuperNoteFeature(): EditorFeatureDescription {
-  return FindNativeFeature(FeatureIdentifier.SuperEditor) as EditorFeatureDescription
+  return FindNativeFeature(NativeFeatureIdentifier.TYPES.SuperEditor) as EditorFeatureDescription
 }
 
 export function GetPlainNoteFeature(): EditorFeatureDescription {
-  return FindNativeFeature(FeatureIdentifier.PlainEditor) as EditorFeatureDescription
+  return FindNativeFeature(NativeFeatureIdentifier.TYPES.PlainEditor) as EditorFeatureDescription
 }
 
 export function GetNativeThemes(): ThemeFeatureDescription[] {
   return themes()
 }
 
 export function GetDarkThemeFeature(): ThemeFeatureDescription {
-  return themes().find((t) => t.identifier === FeatureIdentifier.DarkTheme) as ThemeFeatureDescription
+  return themes().find((t) => t.identifier === NativeFeatureIdentifier.TYPES.DarkTheme) as ThemeFeatureDescription
 }

packages/features/src/Domain/Feature/NativeFeatureIdentifier.ts

@@ -0,0 +1,75 @@
+import { Result, ValueObject } from '@standardnotes/domain-core'
+
+export interface NativeFeatureIdentifierProps {
+  value: string
+}
+
+export class NativeFeatureIdentifier extends ValueObject<NativeFeatureIdentifierProps> {
+  static readonly TYPES = {
+    DailyEmailBackup: 'org.standardnotes.daily-email-backup',
+    Files: 'org.standardnotes.files',
+    FilesLowStorageTier: 'org.standardnotes.files-low-storage-tier',
+    FilesMaximumStorageTier: 'org.standardnotes.files-max-storage-tier',
+    ListedCustomDomain: 'org.standardnotes.listed-custom-domain',
+    NoteHistory30Days: 'org.standardnotes.note-history-30',
+    NoteHistory365Days: 'org.standardnotes.note-history-365',
+    NoteHistoryUnlimited: 'org.standardnotes.note-history-unlimited',
+    SignInAlerts: 'com.standardnotes.sign-in-alerts',
+    SmartFilters: 'org.standardnotes.smart-filters',
+    TagNesting: 'org.standardnotes.tag-nesting',
+    TwoFactorAuth: 'org.standardnotes.two-factor-auth',
+    UniversalSecondFactor: 'org.standardnotes.universal-second-factor',
+    SubscriptionSharing: 'org.standardnotes.subscription-sharing',
+
+    AutobiographyTheme: 'org.standardnotes.theme-autobiography',
+    DynamicTheme: 'org.standardnotes.theme-dynamic',
+    DarkTheme: 'org.standardnotes.theme-focus',
+    FuturaTheme: 'org.standardnotes.theme-futura',
+    MidnightTheme: 'org.standardnotes.theme-midnight',
+    SolarizedDarkTheme: 'org.standardnotes.theme-solarized-dark',
+    TitaniumTheme: 'org.standardnotes.theme-titanium',
+
+    PlainEditor: 'com.standardnotes.plain-text',
+    SuperEditor: 'com.standardnotes.super-editor',
+
+    CodeEditor: 'org.standardnotes.code-editor',
+    MarkdownProEditor: 'org.standardnotes.advanced-markdown-editor',
+    PlusEditor: 'org.standardnotes.plus-editor',
+    SheetsEditor: 'org.standardnotes.standard-sheets',
+    TaskEditor: 'org.standardnotes.simple-task-editor',
+    TokenVaultEditor: 'org.standardnotes.token-vault',
+
+    Clipper: 'org.standardnotes.clipper',
+
+    DeprecatedMarkdownVisualEditor: 'org.standardnotes.markdown-visual-editor',
+    DeprecatedBoldEditor: 'org.standardnotes.bold-editor',
+    DeprecatedMarkdownBasicEditor: 'org.standardnotes.simple-markdown-editor',
+    DeprecatedMarkdownMathEditor: 'org.standardnotes.fancy-markdown-editor',
+    DeprecatedMarkdownMinimistEditor: 'org.standardnotes.minimal-markdown-editor',
+    DeprecatedFoldersComponent: 'org.standardnotes.folders',
+    DeprecatedFileSafe: 'org.standardnotes.file-safe',
+    LegacyFileSafeIdentifier: 'org.standardnotes.legacy.file-safe',
+  }
+
+  get value(): string {
+    return this.props.value
+  }
+
+  private constructor(props: NativeFeatureIdentifierProps) {
+    super(props)
+  }
+
+  static create(type: string): Result<NativeFeatureIdentifier> {
+    const isValidType = Object.values(this.TYPES).includes(type)
+    if (!isValidType) {
+      return Result.fail<NativeFeatureIdentifier>(`Invalid feature identifier: ${type}`)
+    } else {
+      return Result.ok<NativeFeatureIdentifier>(new NativeFeatureIdentifier({ value: type }))
+    }
+  }
+}
+
+/**
+ * Identifier for standalone filesafe instance offered as legacy installable via extensions-server
+ */
+export const ExperimentalFeatures = []

packages/features/src/Domain/Feature/ServerFeatureDescription.ts

@@ -1,11 +1,10 @@
 import { PermissionName } from '../Permission/PermissionName'
-import { FeatureIdentifier } from './FeatureIdentifier'
 import { RoleFields } from './RoleFields'
 
 export type ServerFeatureDescription = RoleFields & {
   name: string
   description?: string
-  identifier: FeatureIdentifier
+  identifier: string
   permission_name: PermissionName
   deprecated?: boolean
 }

packages/features/src/Domain/Lists/ClientFeatures.ts

@@ -1,5 +1,5 @@
 import { PermissionName } from '../Permission/PermissionName'
-import { FeatureIdentifier } from '../Feature/FeatureIdentifier'
+import { NativeFeatureIdentifier } from '../Feature/NativeFeatureIdentifier'
 import { RoleName } from '@standardnotes/domain-core'
 import { ClientFeatureDescription } from '../Feature/ClientFeatureDescription'
 
@@ -8,30 +8,30 @@ export function clientFeatures(): ClientFeatureDescription[] {
     {
       name: 'Tag Nesting',
       availableInRoles: [RoleName.NAMES.PlusUser, RoleName.NAMES.ProUser],
-      identifier: FeatureIdentifier.TagNesting,
+      identifier: NativeFeatureIdentifier.TYPES.TagNesting,
       permission_name: PermissionName.TagNesting,
       description: 'Organize your tags into folders.',
     },
 
     {
       name: 'Smart Filters',
       availableInRoles: [RoleName.NAMES.PlusUser, RoleName.NAMES.ProUser],
-      identifier: FeatureIdentifier.SmartFilters,
+      identifier: NativeFeatureIdentifier.TYPES.SmartFilters,
       permission_name: PermissionName.SmartFilters,
       description: 'Create smart filters for viewing notes matching specific criteria.',
     },
     {
       name: 'Encrypted files',
       availableInRoles: [RoleName.NAMES.PlusUser, RoleName.NAMES.ProUser],
-      identifier: FeatureIdentifier.Files,
+      identifier: NativeFeatureIdentifier.TYPES.Files,
       permission_name: PermissionName.Files,
       description: '',
     },
     {
-      name: 'Extension',
+      name: 'Clipper',
       availableInRoles: [RoleName.NAMES.PlusUser, RoleName.NAMES.ProUser],
-      identifier: FeatureIdentifier.Extension,
-      permission_name: PermissionName.Extension,
+      identifier: NativeFeatureIdentifier.TYPES.Clipper,
+      permission_name: PermissionName.Clipper,
       description: '',
     },
   ]

packages/features/src/Domain/Lists/DeprecatedFeatures.ts

@@ -3,7 +3,7 @@ import { EditorFeatureDescription } from '../Feature/EditorFeatureDescription'
 import { IframeComponentFeatureDescription } from '../Feature/IframeComponentFeatureDescription'
 import { ContentType, RoleName } from '@standardnotes/domain-core'
 import { PermissionName } from '../Permission/PermissionName'
-import { FeatureIdentifier } from '../Feature/FeatureIdentifier'
+import { NativeFeatureIdentifier } from '../Feature/NativeFeatureIdentifier'
 import { NoteType } from '../Component/NoteType'
 import { FillIframeEditorDefaults } from './Utilities/FillEditorComponentDefaults'
 import { ComponentAction } from '../Component/ComponentAction'
@@ -12,7 +12,7 @@ import { ComponentArea } from '../Component/ComponentArea'
 export function GetDeprecatedFeatures(): AnyFeatureDescription[] {
   const bold: EditorFeatureDescription = FillIframeEditorDefaults({
     name: 'Alternative Rich Text',
-    identifier: FeatureIdentifier.DeprecatedBoldEditor,
+    identifier: NativeFeatureIdentifier.TYPES.DeprecatedBoldEditor,
     note_type: NoteType.RichText,
     file_type: 'html',
     component_permissions: [
@@ -39,7 +39,7 @@ export function GetDeprecatedFeatures(): AnyFeatureDescription[] {
 
   const markdownBasic: EditorFeatureDescription = FillIframeEditorDefaults({
     name: 'Basic Markdown',
-    identifier: FeatureIdentifier.DeprecatedMarkdownBasicEditor,
+    identifier: NativeFeatureIdentifier.TYPES.DeprecatedMarkdownBasicEditor,
     note_type: NoteType.Markdown,
     spellcheckControl: true,
     file_type: 'md',
@@ -52,7 +52,7 @@ export function GetDeprecatedFeatures(): AnyFeatureDescription[] {
 
   const markdownAlt: EditorFeatureDescription = FillIframeEditorDefaults({
     name: 'Markdown Alternative',
-    identifier: FeatureIdentifier.DeprecatedMarkdownVisualEditor,
+    identifier: NativeFeatureIdentifier.TYPES.DeprecatedMarkdownVisualEditor,
     note_type: NoteType.Markdown,
     file_type: 'md',
     deprecated: true,
@@ -66,7 +66,7 @@ export function GetDeprecatedFeatures(): AnyFeatureDescription[] {
 
   const markdownMinimist: EditorFeatureDescription = FillIframeEditorDefaults({
     name: 'Minimal Markdown',
-    identifier: FeatureIdentifier.DeprecatedMarkdownMinimistEditor,
+    identifier: NativeFeatureIdentifier.TYPES.DeprecatedMarkdownMinimistEditor,
     note_type: NoteType.Markdown,
     file_type: 'md',
     index_path: 'index.html',
@@ -80,7 +80,7 @@ export function GetDeprecatedFeatures(): AnyFeatureDescription[] {
 
   const markdownMath: EditorFeatureDescription = FillIframeEditorDefaults({
     name: 'Markdown with Math',
-    identifier: FeatureIdentifier.DeprecatedMarkdownMathEditor,
+    identifier: NativeFeatureIdentifier.TYPES.DeprecatedMarkdownMathEditor,
     spellcheckControl: true,
     permission_name: PermissionName.MarkdownMathEditor,
     note_type: NoteType.Markdown,
@@ -94,7 +94,7 @@ export function GetDeprecatedFeatures(): AnyFeatureDescription[] {
 
   const filesafe: IframeComponentFeatureDescription = FillIframeEditorDefaults({
     name: 'FileSafe',
-    identifier: FeatureIdentifier.DeprecatedFileSafe,
+    identifier: NativeFeatureIdentifier.TYPES.DeprecatedFileSafe,
     component_permissions: [
       {
         name: ComponentAction.StreamContextItem,