@vived/core 1.4.2 → 1.4.4

package/dist/types/ExampleFeature/Entities/ExampleEntity.d.ts

@@ -0,0 +1,55 @@
+/**
+ * ExampleEntity.ts
+ *
+ * This file demonstrates how to implement a standard (non-singleton) entity in the application.
+ * Entities store and manage data, track state changes, and notify observers when changes occur.
+ *
+ * Key concepts:
+ * - Entity classes extend AppObjectEntity
+ * - They provide access to data properties
+ * - They use Memoized types (MemoizedString, MemoizedBoolean, etc.) to track changes
+ * - They notify observers when properties change
+ *
+ * Usage pattern:
+ * 1. Get or create an entity instance using getById, get, or addIfMissing
+ * 2. Access or modify properties via getters/setters
+ * 3. Register change observers to react to property updates
+ */
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../AppObject";
+/**
+ * ExampleEntity represents a basic entity with a string property.
+ * Abstract class provides the interface and static helper methods.
+ */
+export declare abstract class ExampleEntity extends AppObjectEntity {
+    /** Unique type identifier for this component */
+    static readonly type = "ExampleEntityType";
+    /** String property accessor methods that must be implemented */
+    abstract get aStringProperty(): string;
+    abstract set aStringProperty(val: string);
+    /**
+     * Retrieves an ExampleEntity component from an AppObject
+     * @param appObj The AppObject to get the component from
+     * @returns The ExampleEntity component or undefined if not found
+     */
+    static get(appObj: AppObject): ExampleEntity | undefined;
+    /**
+     * Retrieves an ExampleEntity by its parent AppObject's ID
+     * @param id The ID of the parent AppObject
+     * @param appObjects The AppObjectRepo to search in
+     * @returns The ExampleEntity component or undefined if not found
+     */
+    static getById(id: string, appObjects: AppObjectRepo): ExampleEntity | undefined;
+    /**
+     * Ensures an ExampleEntity exists on the AppObject, creating one if needed
+     * @param appObj The AppObject to check/add the component to
+     * @returns The existing or newly created ExampleEntity
+     */
+    static addIfMissing(appObj: AppObject): ExampleEntity;
+}
+/**
+ * Factory function to create a new ExampleEntity
+ * @param appObject The AppObject to attach the entity to
+ * @returns A new ExampleEntity instance
+ */
+export declare function makeExampleEntity(appObject: AppObject): ExampleEntity;
+//# sourceMappingURL=ExampleEntity.d.ts.map

package/dist/types/ExampleFeature/Entities/ExampleEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExampleEntity.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/Entities/ExampleEntity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,SAAS,EACT,eAAe,EACf,aAAa,EACd,MAAM,iBAAiB,CAAC;AAGzB;;;GAGG;AACH,8BAAsB,aAAc,SAAQ,eAAe;IACzD,gDAAgD;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,uBAAuB;IAE3C,gEAAgE;IAChE,QAAQ,KAAK,eAAe,IAAI,MAAM,CAAC;IACvC,QAAQ,KAAK,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE;IAE1C;;;;OAIG;IACH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,SAAS;IAIxD;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CACZ,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,GACxB,aAAa,GAAG,SAAS;IAI5B;;;;OAIG;IACH,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,aAAa;CAQtD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,SAAS,GACnB,aAAa,CAEf"}

package/dist/types/ExampleFeature/Entities/ExampleRepo.d.ts

@@ -0,0 +1,62 @@
+/**
+ * ExampleRepo.ts
+ *
+ * This file demonstrates how to implement a repository to manage collections of entities.
+ * Repositories are responsible for creating, retrieving, and deleting entities.
+ *
+ * Key concepts:
+ * - Repositories extend AppObjectEntityRepo<T> where T is the entity type
+ * - They provide methods to create and delete entities
+ * - They manage collections of entities and provide access to them
+ * - They can use custom entity factories to create specialized entities
+ *
+ * Usage pattern:
+ * 1. Get or create a repository using getById, get, or addIfMissing
+ * 2. Use the repository to create new entities
+ * 3. Access entities through the repository's getters
+ * 4. Delete entities through the repository when they're no longer needed
+ */
+import { AppObject, AppObjectEntityRepo, AppObjectRepo } from "../../AppObject";
+import { ExampleEntity } from "./ExampleEntity";
+/** Type definition for a factory function that creates ExampleEntity instances */
+export type ExampleEntityFactory = (id: string) => ExampleEntity;
+/**
+ * ExampleRepo manages a collection of ExampleEntity instances.
+ * Abstract class provides the interface and static helper methods.
+ */
+export declare abstract class ExampleRepo extends AppObjectEntityRepo<ExampleEntity> {
+    /** Unique type identifier for this component */
+    static readonly type = "ExampleRepoType";
+    /** Factory function used to create new entities */
+    abstract exampleEntityFactory: ExampleEntityFactory;
+    /** Creates a new entity with an optional ID */
+    abstract createExampleEntity(id?: string): ExampleEntity;
+    /** Deletes an entity by its AppObject ID */
+    abstract deleteExampleEntity(id: string): void;
+    /**
+     * Retrieves an ExampleRepo component from an AppObject
+     * @param appObj The AppObject to get the component from
+     * @returns The ExampleRepo component or undefined if not found
+     */
+    static get(appObj: AppObject): ExampleRepo | undefined;
+    /**
+     * Retrieves an ExampleRepo by its parent AppObject's ID
+     * @param id The ID of the parent AppObject
+     * @param appObjects The AppObjectRepo to search in
+     * @returns The ExampleRepo component or undefined if not found
+     */
+    static getById(id: string, appObjects: AppObjectRepo): ExampleRepo | undefined;
+    /**
+     * Ensures an ExampleRepo exists on the AppObject, creating one if needed
+     * @param appObject The AppObject to check/add the component to
+     * @returns The existing or newly created ExampleRepo
+     */
+    static addIfMissing(appObject: AppObject): ExampleRepo;
+}
+/**
+ * Factory function to create a new ExampleRepo
+ * @param appObject The AppObject to attach the repo to
+ * @returns A new ExampleRepo instance
+ */
+export declare function makeExampleRepo(appObject: AppObject): ExampleRepo;
+//# sourceMappingURL=ExampleRepo.d.ts.map

package/dist/types/ExampleFeature/Entities/ExampleRepo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExampleRepo.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/Entities/ExampleRepo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EACL,SAAS,EACT,mBAAmB,EACnB,aAAa,EACd,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,aAAa,EAAqB,MAAM,iBAAiB,CAAC;AAEnE,kFAAkF;AAClF,MAAM,MAAM,oBAAoB,GAAG,CAAC,EAAE,EAAE,MAAM,KAAK,aAAa,CAAC;AAEjE;;;GAGG;AACH,8BAAsB,WAAY,SAAQ,mBAAmB,CAAC,aAAa,CAAC;IAC1E,gDAAgD;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,qBAAqB;IAEzC,mDAAmD;IACnD,QAAQ,CAAC,oBAAoB,EAAE,oBAAoB,CAAC;IAEpD,+CAA+C;IAC/C,QAAQ,CAAC,mBAAmB,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa;IAExD,4CAA4C;IAC5C,QAAQ,CAAC,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAE9C;;;;OAIG;IACH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,SAAS;IAItD;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CACZ,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,GACxB,WAAW,GAAG,SAAS;IAI1B;;;;OAIG;IACH,MAAM,CAAC,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,WAAW;CAQvD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,SAAS,GAAG,WAAW,CAEjE"}

package/dist/types/ExampleFeature/Entities/ExampleSingletonEntity.d.ts

@@ -0,0 +1,43 @@
+/**
+ * ExampleSingletonEntity.ts
+ *
+ * This file demonstrates how to implement a singleton entity in the application.
+ * Singleton entities are special entities that exist only once in the application
+ * and can be accessed globally from anywhere.
+ *
+ * Key concepts:
+ * - Singleton entities extend AppObjectEntity like regular entities
+ * - They register themselves as singletons with appObjects.registerSingleton()
+ * - They're accessed through a static get() method using getSingletonComponent()
+ * - There's only one instance of a singleton entity in the entire application
+ *
+ * Usage pattern:
+ * 1. Access the singleton entity using the static get() method
+ * 2. Access or modify properties via getters/setters
+ * 3. Register change observers to react to property updates
+ */
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../AppObject";
+/**
+ * SingletonEntityExample represents a global entity with a boolean property.
+ * As a singleton, only one instance exists in the application.
+ */
+export declare abstract class SingletonEntityExample extends AppObjectEntity {
+    /** Unique type identifier for this component */
+    static readonly type = "SingletonEntityExampleType";
+    /** Boolean property accessor methods that must be implemented */
+    abstract get aBoolProperty(): boolean;
+    abstract set aBoolProperty(val: boolean);
+    /**
+     * Global accessor for the singleton entity
+     * @param appObjects The AppObjectRepo to search in
+     * @returns The singleton entity or undefined if not created yet
+     */
+    static get: (appObjects: AppObjectRepo) => SingletonEntityExample | undefined;
+}
+/**
+ * Factory function to create a new SingletonEntityExample
+ * @param appObject The AppObject to attach the entity to
+ * @returns A new SingletonEntityExample instance
+ */
+export declare function makeSingletonEntityExample(appObject: AppObject): SingletonEntityExample;
+//# sourceMappingURL=ExampleSingletonEntity.d.ts.map

package/dist/types/ExampleFeature/Entities/ExampleSingletonEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExampleSingletonEntity.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/Entities/ExampleSingletonEntity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EACL,SAAS,EACT,eAAe,EACf,aAAa,EACd,MAAM,iBAAiB,CAAC;AAIzB;;;GAGG;AACH,8BAAsB,sBAAuB,SAAQ,eAAe;IAClE,gDAAgD;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,gCAAgC;IAEpD,iEAAiE;IACjE,QAAQ,KAAK,aAAa,IAAI,OAAO,CAAC;IACtC,QAAQ,KAAK,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE;IAEzC;;;;OAIG;IACH,MAAM,CAAC,GAAG,GACR,YAAY,aAAa,KACxB,sBAAsB,GAAG,SAAS,CAC4B;CAClE;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,SAAS,GACnB,sBAAsB,CAExB"}

package/dist/types/ExampleFeature/Entities/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ExampleEntity";
+export * from "./ExampleRepo";
+export * from "./ExampleSingletonEntity";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ExampleFeature/Entities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/Entities/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC"}

package/dist/types/ExampleFeature/Factory/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./setupExampleFeature";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ExampleFeature/Factory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/Factory/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/types/ExampleFeature/Factory/setupExampleFeature.d.ts

@@ -0,0 +1,17 @@
+/**
+ * setupExampleFeature.ts
+ *
+ * This file provides a setup function to initialize the ExampleFeature components.
+ * It creates a dedicated AppObject for ExampleFeature and adds all required
+ * singleton components to it.
+ */
+import { AppObjectRepo } from "../../AppObject";
+import { SingletonEntityExample } from "../Entities/ExampleSingletonEntity";
+/**
+ * Sets up the ExampleFeature by creating an AppObject and attaching required components.
+ *
+ * @param appObjects - Repository of AppObjects to use for creating the feature
+ * @returns The singleton entity instance
+ */
+export declare function setupExampleFeature(appObjects: AppObjectRepo): SingletonEntityExample;
+//# sourceMappingURL=setupExampleFeature.d.ts.map

package/dist/types/ExampleFeature/Factory/setupExampleFeature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setupExampleFeature.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/Factory/setupExampleFeature.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAA8B,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAIxG;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,aAAa,GAAG,sBAAsB,CAUrF"}

package/dist/types/ExampleFeature/Mocks/MockEditExampleStringUC.d.ts

@@ -0,0 +1,42 @@
+/**
+ * MockEditExampleStringUC.ts
+ *
+ * This file demonstrates how to implement a mock UC for testing.
+ * Mock UCs extend the real UC classes but override their methods with test implementations.
+ * This allows tests to verify that the UC methods are called correctly without
+ * actually modifying entities or performing real operations.
+ *
+ * Key concepts:
+ * - Mock UCs extend the real UC classes
+ * - They override methods with test implementations (often empty or spy functions)
+ * - They're used in unit tests to isolate components from their dependencies
+ * - They help verify that methods are called with the correct parameters
+ *
+ * Usage pattern (in tests):
+ * ```typescript
+ * // In a test file
+ * const mockUC = new MockEditExampleStringUC(appObject);
+ * const spy = jest.spyOn(mockUC, 'editExampleString');
+ *
+ * // Call the function that should use the UC
+ * someFunction(appObject);
+ *
+ * // Verify the UC method was called correctly
+ * expect(spy).toHaveBeenCalledWith('expected value');
+ * ```
+ */
+import { AppObject } from "../../AppObject";
+import { EditExampleStringUC } from "../UCs/EditExampleStringUC";
+/**
+ * Mock implementation of EditExampleStringUC for testing
+ * Provides a no-op implementation of editExampleString that can be spied on in tests
+ */
+export declare class MockEditExampleStringUC extends EditExampleStringUC {
+    /**
+     * Mock implementation that does nothing
+     * In tests, this can be replaced with a Jest spy to track calls
+     */
+    editExampleString: (text: string) => void;
+    constructor(appObject: AppObject);
+}
+//# sourceMappingURL=MockEditExampleStringUC.d.ts.map

package/dist/types/ExampleFeature/Mocks/MockEditExampleStringUC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockEditExampleStringUC.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/Mocks/MockEditExampleStringUC.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE;;;GAGG;AACH,qBAAa,uBAAwB,SAAQ,mBAAmB;IAC9D;;;OAGG;IACH,iBAAiB,GAAI,MAAM,MAAM,KAAG,IAAI,CAAO;gBAEnC,SAAS,EAAE,SAAS;CAGjC"}

package/dist/types/ExampleFeature/Mocks/MockExamplePM.d.ts

@@ -0,0 +1,41 @@
+/**
+ * MockExamplePM.ts
+ *
+ * This file demonstrates how to implement a mock PM for testing.
+ * Mock PMs extend the real PM classes but override their methods with test implementations.
+ * This allows tests to verify PM behavior without depending on real entities.
+ *
+ * Key concepts:
+ * - Mock PMs extend the real PM classes
+ * - They override methods with test implementations
+ * - They're used in unit tests to isolate components from their dependencies
+ * - They help test adapters and other components that use PMs
+ *
+ * Usage pattern (in tests):
+ * ```typescript
+ * // In a test file
+ * const mockPM = new MockExamplePM(appObject);
+ * const addViewSpy = jest.spyOn(mockPM, 'addView');
+ *
+ * // Test the component that uses the PM
+ * adapter.subscribe(id, appObjects, setVM);
+ *
+ * // Verify the PM method was called correctly
+ * expect(addViewSpy).toHaveBeenCalledWith(setVM);
+ * ```
+ */
+import { AppObject } from "../../AppObject";
+import { ExamplePM } from "../PMs/ExamplePM";
+/**
+ * Mock implementation of ExamplePM for testing
+ * Provides simplified implementations of required methods
+ */
+export declare class MockExamplePM extends ExamplePM {
+    /**
+     * Simplified implementation that always returns true
+     * This avoids the need to implement real comparison logic in tests
+     */
+    vmsAreEqual: () => boolean;
+    constructor(appObject: AppObject);
+}
+//# sourceMappingURL=MockExamplePM.d.ts.map

package/dist/types/ExampleFeature/Mocks/MockExamplePM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockExamplePM.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/Mocks/MockExamplePM.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C;;;GAGG;AACH,qBAAa,aAAc,SAAQ,SAAS;IAC1C;;;OAGG;IACH,WAAW,gBAET;gBAEU,SAAS,EAAE,SAAS;CAGjC"}

package/dist/types/ExampleFeature/Mocks/MockExampleSingletonPM.d.ts

@@ -0,0 +1,49 @@
+/**
+ * MockExampleSingletonPM.ts
+ *
+ * This file demonstrates how to implement a mock singleton PM for testing.
+ * Mock singleton PMs extend the real singleton PM classes and provide helper
+ * functions to create and access them in tests.
+ *
+ * Key concepts:
+ * - Mock singleton PMs extend the real singleton PM classes
+ * - They override methods with test implementations
+ * - They include helper functions to create and access them in tests
+ * - They're used to test adapters and controllers that depend on singleton PMs
+ *
+ * Usage pattern (in tests):
+ * ```typescript
+ * // In a test file
+ * const mockPM = makeMockExampleSingletonPM(appObjects);
+ * const addViewSpy = jest.spyOn(mockPM, 'addView');
+ *
+ * // Test the component that uses the singleton PM
+ * adapter.subscribe(appObjects, setVM);
+ *
+ * // Verify the PM method was called correctly
+ * expect(addViewSpy).toHaveBeenCalledWith(setVM);
+ * ```
+ */
+import { AppObject, AppObjectRepo } from "../../AppObject";
+import { ExampleSingletonPM } from "../PMs/ExampleSingletonPM";
+/**
+ * Mock implementation of ExampleSingletonPM for testing
+ * Provides simplified implementations of required methods
+ */
+export declare class MockExampleSingletonPM extends ExampleSingletonPM {
+    /**
+     * Simplified implementation that always returns true
+     * This avoids the need to implement real comparison logic in tests
+     */
+    vmsAreEqual: () => boolean;
+    constructor(appObject: AppObject);
+}
+/**
+ * Helper function to create and register a MockExampleSingletonPM
+ * Returns the created mock for use in tests
+ *
+ * @param appObjects The AppObjectRepo to register the mock with
+ * @returns A new MockExampleSingletonPM instance
+ */
+export declare function makeMockExampleSingletonPM(appObjects: AppObjectRepo): MockExampleSingletonPM;
+//# sourceMappingURL=MockExampleSingletonPM.d.ts.map

package/dist/types/ExampleFeature/Mocks/MockExampleSingletonPM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockExampleSingletonPM.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/Mocks/MockExampleSingletonPM.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,kBAAkB;IAC5D;;;OAGG;IACH,WAAW,gBAET;gBAEU,SAAS,EAAE,SAAS;CAGjC;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,aAAa,0BAInE"}

package/dist/types/ExampleFeature/Mocks/MockToggleExampleBooleanUC.d.ts

@@ -0,0 +1,47 @@
+/**
+ * MockToggleExampleBooleanUC.ts
+ *
+ * This file demonstrates how to implement a mock singleton UC for testing.
+ * Mock singleton UCs extend the real UC classes and provide helper functions
+ * to create and register them as singletons for tests.
+ *
+ * Key concepts:
+ * - Mock singleton UCs extend the real UC classes
+ * - They override methods with test implementations
+ * - They register themselves as singletons just like the real UCs
+ * - They include helper functions to create them in tests
+ *
+ * Usage pattern (in tests):
+ * ```typescript
+ * // In a test file
+ * const mockUC = makeMockToggleExampleBooleanUC(appObject);
+ * const spy = jest.spyOn(mockUC, 'toggleExampleBoolean');
+ *
+ * // Call the function that should use the UC
+ * toggleExampleBoolean(appObjects);
+ *
+ * // Verify the UC method was called correctly
+ * expect(spy).toHaveBeenCalled();
+ * ```
+ */
+import { AppObject } from "../../AppObject";
+import { ToggleExampleBooleanUC } from "../UCs/ToggleExampleBooleanUC";
+/**
+ * Mock implementation of ToggleExampleBooleanUC for testing
+ * Provides a no-op implementation of toggleExampleBoolean that can be spied on in tests
+ */
+export declare class MockToggleExampleBooleanUC extends ToggleExampleBooleanUC {
+    /**
+     * Mock implementation that does nothing
+     * In tests, this can be replaced with a Jest spy to track calls
+     */
+    toggleExampleBoolean: () => void;
+    constructor(appObject: AppObject);
+}
+/**
+ * Helper factory function to create a mock ToggleExampleBooleanUC
+ * @param appObject The AppObject to attach the UC to
+ * @returns A new MockToggleExampleBooleanUC instance
+ */
+export declare function makeMockToggleExampleBooleanUC(appObject: AppObject): MockToggleExampleBooleanUC;
+//# sourceMappingURL=MockToggleExampleBooleanUC.d.ts.map

package/dist/types/ExampleFeature/Mocks/MockToggleExampleBooleanUC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockToggleExampleBooleanUC.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/Mocks/MockToggleExampleBooleanUC.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAEvE;;;GAGG;AACH,qBAAa,0BAA2B,SAAQ,sBAAsB;IACpE;;;OAGG;IACH,oBAAoB,QAAO,IAAI,CAAO;gBAE1B,SAAS,EAAE,SAAS;CAKjC;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,SAAS,GACnB,0BAA0B,CAE5B"}

package/dist/types/ExampleFeature/Mocks/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./MockEditExampleStringUC";
+export * from "./MockExamplePM";
+export * from "./MockExampleSingletonPM";
+export * from "./MockToggleExampleBooleanUC";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ExampleFeature/Mocks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/Mocks/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC"}

package/dist/types/ExampleFeature/PMs/ExamplePM.d.ts

@@ -0,0 +1,42 @@
+/**
+ * ExamplePM.ts
+ *
+ * This file demonstrates how to implement a Presentation Manager (PM) component.
+ * PMs are responsible for transforming entity data into view models (VMs) for the UI.
+ * They observe entities for changes and update their views when data changes.
+ *
+ * Key concepts:
+ * - PMs extend AppObjectPM<VM> where VM is the view model type
+ * - They observe entities and transform entity data into view models
+ * - They notify UI components (views) when view models change
+ * - Each PM instance is associated with a specific AppObject
+ *
+ * Usage pattern:
+ * 1. Get a PM instance using getById
+ * 2. Register UI components as views using addView(callback)
+ * 3. PM will call the view callbacks with updated view models when entities change
+ * 4. Remove UI components with removeView(callback) when they're unmounted
+ */
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../AppObject";
+/**
+ * ExamplePM transforms ExampleEntity data into a simple string view model.
+ * Abstract class provides the interface and static helper methods.
+ */
+export declare abstract class ExamplePM extends AppObjectPM<string> {
+    /** Unique type identifier for this component */
+    static readonly type = "ExamplePMType";
+    /**
+     * Retrieves an ExamplePM by its parent AppObject's ID
+     * @param id The ID of the parent AppObject
+     * @param appObjects The AppObjectRepo to search in
+     * @returns The ExamplePM component or undefined if not found
+     */
+    static getById(id: string, appObjects: AppObjectRepo): ExamplePM | undefined;
+}
+/**
+ * Factory function to create a new ExamplePM
+ * @param appObject The AppObject to attach the PM to
+ * @returns A new ExamplePM instance
+ */
+export declare function makeExamplePM(appObject: AppObject): ExamplePM;
+//# sourceMappingURL=ExamplePM.d.ts.map

package/dist/types/ExampleFeature/PMs/ExamplePM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExamplePM.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/PMs/ExamplePM.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGxE;;;GAGG;AACH,8BAAsB,SAAU,SAAQ,WAAW,CAAC,MAAM,CAAC;IACzD,gDAAgD;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,mBAAmB;IAEvC;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa;CAGrD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,CAE7D"}

package/dist/types/ExampleFeature/PMs/ExampleSingletonPM.d.ts

@@ -0,0 +1,52 @@
+/**
+ * ExampleSingletonPM.ts
+ *
+ * This file demonstrates how to implement a Singleton Presentation Manager (PM).
+ * Singleton PMs are special PMs that exist only once in the application and can be
+ * accessed globally. They transform data from singleton entities into view models.
+ *
+ * Key concepts:
+ * - Singleton PMs extend AppObjectPM<VM> like regular PMs
+ * - They register themselves as singletons with appObjects.registerSingleton()
+ * - They're accessed through a static get() method using getSingletonComponent()
+ * - They typically observe singleton entities and provide data to multiple UI components
+ *
+ * Usage pattern:
+ * 1. Access the singleton PM using the static get() method
+ * 2. Register UI components as views using addView(callback)
+ * 3. PM will call the view callbacks with updated view models when entities change
+ * 4. Remove UI components with removeView(callback) when they're unmounted
+ */
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../AppObject";
+/**
+ * Interface defining the structure of the view model provided by ExampleSingletonPM
+ */
+export interface ExampleVM {
+    aBoolProperty: boolean;
+}
+/**
+ * ExampleSingletonPM transforms SingletonEntityExample data into an ExampleVM.
+ * As a singleton, only one instance exists in the application.
+ */
+export declare abstract class ExampleSingletonPM extends AppObjectPM<ExampleVM> {
+    /** Unique type identifier for this component */
+    static readonly type = "ExampleSingletonPMType";
+    /**
+     * Global accessor for the singleton PM
+     * @param appObjects The AppObjectRepo to search in
+     * @returns The singleton PM or undefined if not created yet
+     */
+    static get: (appObjects: AppObjectRepo) => ExampleSingletonPM | undefined;
+}
+/**
+ * Default view model used when no data is available
+ * UI components can use this initially or when the PM is not found
+ */
+export declare const defaultSlideNavigationVM: ExampleVM;
+/**
+ * Factory function to create a new ExampleSingletonPM
+ * @param appObject The AppObject to attach the PM to
+ * @returns A new ExampleSingletonPM instance
+ */
+export declare function makeExampleSingletonPM(appObject: AppObject): ExampleSingletonPM;
+//# sourceMappingURL=ExampleSingletonPM.d.ts.map

package/dist/types/ExampleFeature/PMs/ExampleSingletonPM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExampleSingletonPM.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/PMs/ExampleSingletonPM.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EACL,SAAS,EACT,WAAW,EACX,aAAa,EACd,MAAM,iBAAiB,CAAC;AAIzB;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED;;;GAGG;AACH,8BAAsB,kBAAmB,SAAQ,WAAW,CAAC,SAAS,CAAC;IACrE,gDAAgD;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,4BAA4B;IAEhD;;;;OAIG;IACH,MAAM,CAAC,GAAG,GAAI,YAAY,aAAa,KAAG,kBAAkB,GAAG,SAAS,CACX;CAC9D;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,EAAE,SAEtC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,SAAS,GACnB,kBAAkB,CAEpB"}

package/dist/types/ExampleFeature/PMs/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ExamplePM";
+export * from "./ExampleSingletonPM";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ExampleFeature/PMs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/PMs/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC"}

package/dist/types/ExampleFeature/UCs/EditExampleStringUC.d.ts

@@ -0,0 +1,52 @@
+/**
+ * EditExampleStringUC.ts
+ *
+ * This file demonstrates how to implement a Use Case (UC) component.
+ * UCs handle business logic and operations that modify entities.
+ * They encapsulate specific actions that can be performed in the application.
+ *
+ * Key concepts:
+ * - UCs extend AppObjectUC and provide methods for specific operations
+ * - They implement business logic for modifying entities
+ * - They validate inputs and handle errors
+ * - Each UC instance is associated with a specific AppObject
+ *
+ * Usage pattern:
+ * 1. Get a UC instance using getById or get
+ * 2. Call the UC's methods to perform operations
+ * 3. The UC will update entities, which will trigger PM updates and UI refreshes
+ */
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../AppObject";
+/**
+ * EditExampleStringUC provides functionality to update the string property of an ExampleEntity.
+ * Abstract class provides the interface and static helper methods.
+ */
+export declare abstract class EditExampleStringUC extends AppObjectUC {
+    /** Unique type identifier for this component */
+    static readonly type = "EditExampleStringUCType";
+    /**
+     * Updates the string property of the associated ExampleEntity
+     * @param text The new string value to set
+     */
+    abstract editExampleString(text: string): void;
+    /**
+     * Retrieves an EditExampleStringUC component from an AppObject
+     * @param appObj The AppObject to get the component from
+     * @returns The EditExampleStringUC component or undefined if not found
+     */
+    static get(appObj: AppObject): EditExampleStringUC | undefined;
+    /**
+     * Retrieves an EditExampleStringUC by its parent AppObject's ID
+     * @param id The ID of the parent AppObject
+     * @param appObjects The AppObjectRepo to search in
+     * @returns The EditExampleStringUC component or undefined if not found
+     */
+    static getById(id: string, appObjects: AppObjectRepo): EditExampleStringUC | undefined;
+}
+/**
+ * Factory function to create a new EditExampleStringUC
+ * @param appObject The AppObject to attach the UC to
+ * @returns A new EditExampleStringUC instance
+ */
+export declare function makeEditSlideTextUC(appObject: AppObject): EditExampleStringUC;
+//# sourceMappingURL=EditExampleStringUC.d.ts.map

package/dist/types/ExampleFeature/UCs/EditExampleStringUC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditExampleStringUC.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/UCs/EditExampleStringUC.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGxE;;;GAGG;AACH,8BAAsB,mBAAoB,SAAQ,WAAW;IAC3D,gDAAgD;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,6BAA6B;IAEjD;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAE9C;;;;OAIG;IACH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,GAAG,mBAAmB,GAAG,SAAS;IAI9D;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CACZ,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,GACxB,mBAAmB,GAAG,SAAS;CAGnC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,SAAS,GAAG,mBAAmB,CAE7E"}

package/dist/types/ExampleFeature/UCs/ToggleExampleBooleanUC.d.ts

@@ -0,0 +1,44 @@
+/**
+ * ToggleExampleBooleanUC.ts
+ *
+ * This file demonstrates how to implement a Singleton Use Case (UC) component.
+ * Singleton UCs are special UCs that exist only once in the application and can be
+ * accessed globally. They handle business logic and operations that modify singleton entities.
+ *
+ * Key concepts:
+ * - Singleton UCs extend AppObjectUC like regular UCs
+ * - They register themselves as singletons with appObjects.registerSingleton()
+ * - They're accessed through a static get() method using getSingletonComponent()
+ * - They typically operate on singleton entities
+ *
+ * Usage pattern:
+ * 1. Access the singleton UC using the static get() method
+ * 2. Call the UC's methods to perform operations
+ * 3. The UC will update entities, which will trigger PM updates and UI refreshes
+ */
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../AppObject";
+/**
+ * ToggleExampleBooleanUC provides functionality to toggle the boolean property
+ * of the SingletonEntityExample. As a singleton, only one instance exists in the application.
+ */
+export declare abstract class ToggleExampleBooleanUC extends AppObjectUC {
+    /** Unique type identifier for this component */
+    static readonly type = "ToggleExampleBooleanUCType";
+    /**
+     * Toggles the boolean property of the SingletonEntityExample
+     */
+    abstract toggleExampleBoolean(): void;
+    /**
+     * Global accessor for the singleton UC
+     * @param appObjects The AppObjectRepo to search in
+     * @returns The singleton UC or undefined if not created yet
+     */
+    static get: (appObjects: AppObjectRepo) => ToggleExampleBooleanUC | undefined;
+}
+/**
+ * Factory function to create a new ToggleExampleBooleanUC
+ * @param appObject The AppObject to attach the UC to
+ * @returns A new ToggleExampleBooleanUC instance
+ */
+export declare function makeToggleExampleBooleanUC(appObject: AppObject): ToggleExampleBooleanUC;
+//# sourceMappingURL=ToggleExampleBooleanUC.d.ts.map

package/dist/types/ExampleFeature/UCs/ToggleExampleBooleanUC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToggleExampleBooleanUC.d.ts","sourceRoot":"","sources":["../../../../src/ExampleFeature/UCs/ToggleExampleBooleanUC.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EACL,SAAS,EACT,aAAa,EACb,WAAW,EACZ,MAAM,iBAAiB,CAAC;AAIzB;;;GAGG;AACH,8BAAsB,sBAAuB,SAAQ,WAAW;IAC9D,gDAAgD;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,gCAAgC;IAEpD;;OAEG;IACH,QAAQ,CAAC,oBAAoB,IAAI,IAAI;IAErC;;;;OAIG;IACH,MAAM,CAAC,GAAG,GACR,YAAY,aAAa,KACxB,sBAAsB,GAAG,SAAS,CAC4B;CAClE;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,SAAS,GACnB,sBAAsB,CAExB"}