@vived/core 1.4.3 → 1.4.4

package/dist/cjs/ExampleFeature/Entities/ExampleSingletonEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExampleSingletonEntity.js","sourceRoot":"","sources":["../../../../src/ExampleFeature/Entities/ExampleSingletonEntity.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;;AAsCH,gEAIC;AAxCD,+CAIyB;AACzB,iFAA8E;AAC9E,oEAAiE;AAEjE;;;GAGG;AACH,MAAsB,sBAAuB,SAAQ,2BAAe;;AAApE,wDAiBC;AAhBC,gDAAgD;AAChC,2BAAI,GAAG,4BAA4B,CAAC;AAMpD;;;;GAIG;AACI,0BAAG,GAAG,CACX,UAAyB,EACW,EAAE,CACtC,IAAA,6CAAqB,EAAC,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;AAGnE;;;;GAIG;AACH,SAAgB,0BAA0B,CACxC,SAAoB;IAEpB,OAAO,IAAI,yBAAyB,CAAC,SAAS,CAAC,CAAC;AAClD,CAAC;AAED;;;GAGG;AACH,MAAM,yBAA0B,SAAQ,sBAAsB;IAI5D,iDAAiD;IACjD,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC;IACtC,CAAC;IAED,IAAI,aAAa,CAAC,GAAY;QAC5B,IAAI,CAAC,mBAAmB,CAAC,GAAG,GAAG,GAAG,CAAC;IACrC,CAAC;IAED,YAAY,SAAoB;QAC9B,KAAK,CAAC,SAAS,EAAE,sBAAsB,CAAC,IAAI,CAAC,CAAC;QAbhD,4FAA4F;QACpF,wBAAmB,GAAG,IAAI,iCAAe,CAAC,KAAK,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAa5E,qEAAqE;QACrE,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;CACF","sourcesContent":["/**\r\n * ExampleSingletonEntity.ts\r\n * \r\n * This file demonstrates how to implement a singleton entity in the application.\r\n * Singleton entities are special entities that exist only once in the application\r\n * and can be accessed globally from anywhere.\r\n * \r\n * Key concepts:\r\n * - Singleton entities extend AppObjectEntity like regular entities\r\n * - They register themselves as singletons with appObjects.registerSingleton()\r\n * - They're accessed through a static get() method using getSingletonComponent()\r\n * - There's only one instance of a singleton entity in the entire application\r\n * \r\n * Usage pattern:\r\n * 1. Access the singleton entity using the static get() method\r\n * 2. Access or modify properties via getters/setters\r\n * 3. Register change observers to react to property updates\r\n */\r\n\r\nimport {\r\n  AppObject,\r\n  AppObjectEntity,\r\n  AppObjectRepo\r\n} from \"../../AppObject\";\r\nimport { getSingletonComponent } from \"../../AppObject/getSingletonComponent\";\r\nimport { MemoizedBoolean } from \"../../Entities/MemoizedBoolean\";\r\n\r\n/**\r\n * SingletonEntityExample represents a global entity with a boolean property.\r\n * As a singleton, only one instance exists in the application.\r\n */\r\nexport abstract class SingletonEntityExample extends AppObjectEntity {\r\n  /** Unique type identifier for this component */\r\n  static readonly type = \"SingletonEntityExampleType\";\r\n\r\n  /** Boolean property accessor methods that must be implemented */\r\n  abstract get aBoolProperty(): boolean;\r\n  abstract set aBoolProperty(val: boolean);\r\n\r\n  /**\r\n   * Global accessor for the singleton entity\r\n   * @param appObjects The AppObjectRepo to search in\r\n   * @returns The singleton entity or undefined if not created yet\r\n   */\r\n  static get = (\r\n    appObjects: AppObjectRepo\r\n  ): SingletonEntityExample | undefined =>\r\n    getSingletonComponent(SingletonEntityExample.type, appObjects);\r\n}\r\n\r\n/**\r\n * Factory function to create a new SingletonEntityExample\r\n * @param appObject The AppObject to attach the entity to\r\n * @returns A new SingletonEntityExample instance\r\n */\r\nexport function makeSingletonEntityExample(\r\n  appObject: AppObject\r\n): SingletonEntityExample {\r\n  return new SingletonEntityExampleImp(appObject);\r\n}\r\n\r\n/**\r\n * Concrete implementation of SingletonEntityExample\r\n * This private class handles the actual implementation details\r\n */\r\nclass SingletonEntityExampleImp extends SingletonEntityExample {\r\n  // MemoizedBoolean tracks changes to the boolean value and calls notifyOnChange when updated\r\n  private memoizedIsAuthoring = new MemoizedBoolean(false, this.notifyOnChange);\r\n  \r\n  // Property accessors that use the memoized value\r\n  get aBoolProperty() {\r\n    return this.memoizedIsAuthoring.val;\r\n  }\r\n  \r\n  set aBoolProperty(val: boolean) {\r\n    this.memoizedIsAuthoring.val = val;\r\n  }\r\n\r\n  constructor(appObject: AppObject) {\r\n    super(appObject, SingletonEntityExample.type);\r\n    // Register this entity as a singleton so it can be accessed globally\r\n    this.appObjects.registerSingleton(this);\r\n  }\r\n}\r\n"]}

package/dist/cjs/ExampleFeature/Entities/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ExampleEntity"), exports);
+__exportStar(require("./ExampleRepo"), exports);
+__exportStar(require("./ExampleSingletonEntity"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/ExampleFeature/Entities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/ExampleFeature/Entities/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAAgC;AAChC,gDAA8B;AAC9B,2DAAyC","sourcesContent":["export * from \"./ExampleEntity\";\r\nexport * from \"./ExampleRepo\";\r\nexport * from \"./ExampleSingletonEntity\";\r\n"]}

package/dist/cjs/ExampleFeature/Factory/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./setupExampleFeature"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/ExampleFeature/Factory/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/ExampleFeature/Factory/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wDAAsC","sourcesContent":["export * from \"./setupExampleFeature\";"]}

package/dist/cjs/ExampleFeature/Factory/setupExampleFeature.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupExampleFeature = setupExampleFeature;
+const ExampleSingletonEntity_1 = require("../Entities/ExampleSingletonEntity");
+const ExampleSingletonPM_1 = require("../PMs/ExampleSingletonPM");
+const ToggleExampleBooleanUC_1 = require("../UCs/ToggleExampleBooleanUC");
+/**
+ * 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
+ */
+function setupExampleFeature(appObjects) {
+    // Create a dedicated AppObject for ExampleFeature
+    const appObject = appObjects.getOrCreate("ExampleFeature");
+    // Add singleton components to the AppObject
+    const entity = (0, ExampleSingletonEntity_1.makeSingletonEntityExample)(appObject);
+    (0, ExampleSingletonPM_1.makeExampleSingletonPM)(appObject);
+    (0, ToggleExampleBooleanUC_1.makeToggleExampleBooleanUC)(appObject);
+    return entity;
+}
+//# sourceMappingURL=setupExampleFeature.js.map

package/dist/cjs/ExampleFeature/Factory/setupExampleFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setupExampleFeature.js","sourceRoot":"","sources":["../../../../src/ExampleFeature/Factory/setupExampleFeature.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AAaH,kDAUC;AApBD,+EAAwG;AACxG,kEAAmE;AACnE,0EAA2E;AAE3E;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,UAAyB;IAC3D,kDAAkD;IAClD,MAAM,SAAS,GAAG,UAAU,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;IAE3D,4CAA4C;IAC5C,MAAM,MAAM,GAAG,IAAA,mDAA0B,EAAC,SAAS,CAAC,CAAC;IACrD,IAAA,2CAAsB,EAAC,SAAS,CAAC,CAAC;IAClC,IAAA,mDAA0B,EAAC,SAAS,CAAC,CAAC;IAEtC,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["/**\r\n * setupExampleFeature.ts\r\n * \r\n * This file provides a setup function to initialize the ExampleFeature components.\r\n * It creates a dedicated AppObject for ExampleFeature and adds all required\r\n * singleton components to it.\r\n */\r\n\r\nimport { AppObjectRepo } from \"../../AppObject\";\r\nimport { makeSingletonEntityExample, SingletonEntityExample } from \"../Entities/ExampleSingletonEntity\";\r\nimport { makeExampleSingletonPM } from \"../PMs/ExampleSingletonPM\";\r\nimport { makeToggleExampleBooleanUC } from \"../UCs/ToggleExampleBooleanUC\";\r\n\r\n/**\r\n * Sets up the ExampleFeature by creating an AppObject and attaching required components.\r\n * \r\n * @param appObjects - Repository of AppObjects to use for creating the feature\r\n * @returns The singleton entity instance\r\n */\r\nexport function setupExampleFeature(appObjects: AppObjectRepo): SingletonEntityExample {\r\n  // Create a dedicated AppObject for ExampleFeature\r\n  const appObject = appObjects.getOrCreate(\"ExampleFeature\");\r\n  \r\n  // Add singleton components to the AppObject\r\n  const entity = makeSingletonEntityExample(appObject);\r\n  makeExampleSingletonPM(appObject);\r\n  makeToggleExampleBooleanUC(appObject);\r\n  \r\n  return entity;\r\n}"]}

package/dist/cjs/ExampleFeature/Mocks/MockEditExampleStringUC.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * 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');
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockEditExampleStringUC = void 0;
+const EditExampleStringUC_1 = require("../UCs/EditExampleStringUC");
+/**
+ * Mock implementation of EditExampleStringUC for testing
+ * Provides a no-op implementation of editExampleString that can be spied on in tests
+ */
+class MockEditExampleStringUC extends EditExampleStringUC_1.EditExampleStringUC {
+    constructor(appObject) {
+        super(appObject, EditExampleStringUC_1.EditExampleStringUC.type);
+        /**
+         * Mock implementation that does nothing
+         * In tests, this can be replaced with a Jest spy to track calls
+         */
+        this.editExampleString = (text) => { };
+    }
+}
+exports.MockEditExampleStringUC = MockEditExampleStringUC;
+//# sourceMappingURL=MockEditExampleStringUC.js.map

package/dist/cjs/ExampleFeature/Mocks/MockEditExampleStringUC.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockEditExampleStringUC.js","sourceRoot":"","sources":["../../../../src/ExampleFeature/Mocks/MockEditExampleStringUC.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;;;AAGH,oEAAiE;AAEjE;;;GAGG;AACH,MAAa,uBAAwB,SAAQ,yCAAmB;IAO9D,YAAY,SAAoB;QAC9B,KAAK,CAAC,SAAS,EAAE,yCAAmB,CAAC,IAAI,CAAC,CAAC;QAP7C;;;WAGG;QACH,sBAAiB,GAAG,CAAC,IAAY,EAAQ,EAAE,GAAE,CAAC,CAAC;IAI/C,CAAC;CACF;AAVD,0DAUC","sourcesContent":["/**\r\n * MockEditExampleStringUC.ts\r\n * \r\n * This file demonstrates how to implement a mock UC for testing.\r\n * Mock UCs extend the real UC classes but override their methods with test implementations.\r\n * This allows tests to verify that the UC methods are called correctly without\r\n * actually modifying entities or performing real operations.\r\n * \r\n * Key concepts:\r\n * - Mock UCs extend the real UC classes\r\n * - They override methods with test implementations (often empty or spy functions)\r\n * - They're used in unit tests to isolate components from their dependencies\r\n * - They help verify that methods are called with the correct parameters\r\n * \r\n * Usage pattern (in tests):\r\n * ```typescript\r\n * // In a test file\r\n * const mockUC = new MockEditExampleStringUC(appObject);\r\n * const spy = jest.spyOn(mockUC, 'editExampleString');\r\n * \r\n * // Call the function that should use the UC\r\n * someFunction(appObject);\r\n * \r\n * // Verify the UC method was called correctly\r\n * expect(spy).toHaveBeenCalledWith('expected value');\r\n * ```\r\n */\r\n\r\nimport { AppObject } from \"../../AppObject\";\r\nimport { EditExampleStringUC } from \"../UCs/EditExampleStringUC\";\r\n\r\n/**\r\n * Mock implementation of EditExampleStringUC for testing\r\n * Provides a no-op implementation of editExampleString that can be spied on in tests\r\n */\r\nexport class MockEditExampleStringUC extends EditExampleStringUC {\r\n  /**\r\n   * Mock implementation that does nothing\r\n   * In tests, this can be replaced with a Jest spy to track calls\r\n   */\r\n  editExampleString = (text: string): void => {};\r\n\r\n  constructor(appObject: AppObject) {\r\n    super(appObject, EditExampleStringUC.type);\r\n  }\r\n}\r\n"]}

package/dist/cjs/ExampleFeature/Mocks/MockExamplePM.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * 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);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockExamplePM = void 0;
+const ExamplePM_1 = require("../PMs/ExamplePM");
+/**
+ * Mock implementation of ExamplePM for testing
+ * Provides simplified implementations of required methods
+ */
+class MockExamplePM extends ExamplePM_1.ExamplePM {
+    constructor(appObject) {
+        super(appObject, ExamplePM_1.ExamplePM.type);
+        /**
+         * Simplified implementation that always returns true
+         * This avoids the need to implement real comparison logic in tests
+         */
+        this.vmsAreEqual = () => {
+            return true;
+        };
+    }
+}
+exports.MockExamplePM = MockExamplePM;
+//# sourceMappingURL=MockExamplePM.js.map

package/dist/cjs/ExampleFeature/Mocks/MockExamplePM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockExamplePM.js","sourceRoot":"","sources":["../../../../src/ExampleFeature/Mocks/MockExamplePM.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;;;AAGH,gDAA6C;AAE7C;;;GAGG;AACH,MAAa,aAAc,SAAQ,qBAAS;IAS1C,YAAY,SAAoB;QAC9B,KAAK,CAAC,SAAS,EAAE,qBAAS,CAAC,IAAI,CAAC,CAAC;QATnC;;;WAGG;QACH,gBAAW,GAAG,GAAG,EAAE;YACjB,OAAO,IAAI,CAAC;QACd,CAAC,CAAC;IAIF,CAAC;CACF;AAZD,sCAYC","sourcesContent":["/**\r\n * MockExamplePM.ts\r\n * \r\n * This file demonstrates how to implement a mock PM for testing.\r\n * Mock PMs extend the real PM classes but override their methods with test implementations.\r\n * This allows tests to verify PM behavior without depending on real entities.\r\n * \r\n * Key concepts:\r\n * - Mock PMs extend the real PM classes\r\n * - They override methods with test implementations\r\n * - They're used in unit tests to isolate components from their dependencies\r\n * - They help test adapters and other components that use PMs\r\n * \r\n * Usage pattern (in tests):\r\n * ```typescript\r\n * // In a test file\r\n * const mockPM = new MockExamplePM(appObject);\r\n * const addViewSpy = jest.spyOn(mockPM, 'addView');\r\n * \r\n * // Test the component that uses the PM\r\n * adapter.subscribe(id, appObjects, setVM);\r\n * \r\n * // Verify the PM method was called correctly\r\n * expect(addViewSpy).toHaveBeenCalledWith(setVM);\r\n * ```\r\n */\r\n\r\nimport { AppObject } from \"../../AppObject\";\r\nimport { ExamplePM } from \"../PMs/ExamplePM\";\r\n\r\n/**\r\n * Mock implementation of ExamplePM for testing\r\n * Provides simplified implementations of required methods\r\n */\r\nexport class MockExamplePM extends ExamplePM {\r\n  /**\r\n   * Simplified implementation that always returns true\r\n   * This avoids the need to implement real comparison logic in tests\r\n   */\r\n  vmsAreEqual = () => {\r\n    return true;\r\n  };\r\n\r\n  constructor(appObject: AppObject) {\r\n    super(appObject, ExamplePM.type);\r\n  }\r\n}\r\n"]}

package/dist/cjs/ExampleFeature/Mocks/MockExampleSingletonPM.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * 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);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockExampleSingletonPM = void 0;
+exports.makeMockExampleSingletonPM = makeMockExampleSingletonPM;
+const ExampleSingletonPM_1 = require("../PMs/ExampleSingletonPM");
+/**
+ * Mock implementation of ExampleSingletonPM for testing
+ * Provides simplified implementations of required methods
+ */
+class MockExampleSingletonPM extends ExampleSingletonPM_1.ExampleSingletonPM {
+    constructor(appObject) {
+        super(appObject, ExampleSingletonPM_1.ExampleSingletonPM.type);
+        /**
+         * Simplified implementation that always returns true
+         * This avoids the need to implement real comparison logic in tests
+         */
+        this.vmsAreEqual = () => {
+            return true;
+        };
+    }
+}
+exports.MockExampleSingletonPM = MockExampleSingletonPM;
+/**
+ * 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
+ */
+function makeMockExampleSingletonPM(appObjects) {
+    return new MockExampleSingletonPM(appObjects.getOrCreate("MockExampleSingletonPM"));
+}
+//# sourceMappingURL=MockExampleSingletonPM.js.map

package/dist/cjs/ExampleFeature/Mocks/MockExampleSingletonPM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockExampleSingletonPM.js","sourceRoot":"","sources":["../../../../src/ExampleFeature/Mocks/MockExampleSingletonPM.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;;;AA8BH,gEAIC;AA/BD,kEAA+D;AAE/D;;;GAGG;AACH,MAAa,sBAAuB,SAAQ,uCAAkB;IAS5D,YAAY,SAAoB;QAC9B,KAAK,CAAC,SAAS,EAAE,uCAAkB,CAAC,IAAI,CAAC,CAAC;QAT5C;;;WAGG;QACH,gBAAW,GAAG,GAAG,EAAE;YACjB,OAAO,IAAI,CAAC;QACd,CAAC,CAAC;IAIF,CAAC;CACF;AAZD,wDAYC;AAED;;;;;;GAMG;AACH,SAAgB,0BAA0B,CAAC,UAAyB;IAClE,OAAO,IAAI,sBAAsB,CAC/B,UAAU,CAAC,WAAW,CAAC,wBAAwB,CAAC,CACjD,CAAC;AACJ,CAAC","sourcesContent":["/**\r\n * MockExampleSingletonPM.ts\r\n * \r\n * This file demonstrates how to implement a mock singleton PM for testing.\r\n * Mock singleton PMs extend the real singleton PM classes and provide helper\r\n * functions to create and access them in tests.\r\n * \r\n * Key concepts:\r\n * - Mock singleton PMs extend the real singleton PM classes\r\n * - They override methods with test implementations\r\n * - They include helper functions to create and access them in tests\r\n * - They're used to test adapters and controllers that depend on singleton PMs\r\n * \r\n * Usage pattern (in tests):\r\n * ```typescript\r\n * // In a test file\r\n * const mockPM = makeMockExampleSingletonPM(appObjects);\r\n * const addViewSpy = jest.spyOn(mockPM, 'addView');\r\n * \r\n * // Test the component that uses the singleton PM\r\n * adapter.subscribe(appObjects, setVM);\r\n * \r\n * // Verify the PM method was called correctly\r\n * expect(addViewSpy).toHaveBeenCalledWith(setVM);\r\n * ```\r\n */\r\n\r\nimport { AppObject, AppObjectRepo } from \"../../AppObject\";\r\nimport { ExampleSingletonPM } from \"../PMs/ExampleSingletonPM\";\r\n\r\n/**\r\n * Mock implementation of ExampleSingletonPM for testing\r\n * Provides simplified implementations of required methods\r\n */\r\nexport class MockExampleSingletonPM extends ExampleSingletonPM {\r\n  /**\r\n   * Simplified implementation that always returns true\r\n   * This avoids the need to implement real comparison logic in tests\r\n   */\r\n  vmsAreEqual = () => {\r\n    return true;\r\n  };\r\n\r\n  constructor(appObject: AppObject) {\r\n    super(appObject, ExampleSingletonPM.type);\r\n  }\r\n}\r\n\r\n/**\r\n * Helper function to create and register a MockExampleSingletonPM\r\n * Returns the created mock for use in tests\r\n * \r\n * @param appObjects The AppObjectRepo to register the mock with\r\n * @returns A new MockExampleSingletonPM instance\r\n */\r\nexport function makeMockExampleSingletonPM(appObjects: AppObjectRepo) {\r\n  return new MockExampleSingletonPM(\r\n    appObjects.getOrCreate(\"MockExampleSingletonPM\")\r\n  );\r\n}\r\n"]}

package/dist/cjs/ExampleFeature/Mocks/MockToggleExampleBooleanUC.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * 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();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockToggleExampleBooleanUC = void 0;
+exports.makeMockToggleExampleBooleanUC = makeMockToggleExampleBooleanUC;
+const ToggleExampleBooleanUC_1 = require("../UCs/ToggleExampleBooleanUC");
+/**
+ * Mock implementation of ToggleExampleBooleanUC for testing
+ * Provides a no-op implementation of toggleExampleBoolean that can be spied on in tests
+ */
+class MockToggleExampleBooleanUC extends ToggleExampleBooleanUC_1.ToggleExampleBooleanUC {
+    constructor(appObject) {
+        super(appObject, ToggleExampleBooleanUC_1.ToggleExampleBooleanUC.type);
+        /**
+         * Mock implementation that does nothing
+         * In tests, this can be replaced with a Jest spy to track calls
+         */
+        this.toggleExampleBoolean = () => { };
+        // Register as a singleton just like the real UC
+        this.appObjects.registerSingleton(this);
+    }
+}
+exports.MockToggleExampleBooleanUC = MockToggleExampleBooleanUC;
+/**
+ * Helper factory function to create a mock ToggleExampleBooleanUC
+ * @param appObject The AppObject to attach the UC to
+ * @returns A new MockToggleExampleBooleanUC instance
+ */
+function makeMockToggleExampleBooleanUC(appObject) {
+    return new MockToggleExampleBooleanUC(appObject);
+}
+//# sourceMappingURL=MockToggleExampleBooleanUC.js.map

package/dist/cjs/ExampleFeature/Mocks/MockToggleExampleBooleanUC.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockToggleExampleBooleanUC.js","sourceRoot":"","sources":["../../../../src/ExampleFeature/Mocks/MockToggleExampleBooleanUC.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;;;AA4BH,wEAIC;AA7BD,0EAAuE;AAEvE;;;GAGG;AACH,MAAa,0BAA2B,SAAQ,+CAAsB;IAOpE,YAAY,SAAoB;QAC9B,KAAK,CAAC,SAAS,EAAE,+CAAsB,CAAC,IAAI,CAAC,CAAC;QAPhD;;;WAGG;QACH,yBAAoB,GAAG,GAAS,EAAE,GAAE,CAAC,CAAC;QAIpC,gDAAgD;QAChD,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;CACF;AAZD,gEAYC;AAED;;;;GAIG;AACH,SAAgB,8BAA8B,CAC5C,SAAoB;IAEpB,OAAO,IAAI,0BAA0B,CAAC,SAAS,CAAC,CAAC;AACnD,CAAC","sourcesContent":["/**\r\n * MockToggleExampleBooleanUC.ts\r\n * \r\n * This file demonstrates how to implement a mock singleton UC for testing.\r\n * Mock singleton UCs extend the real UC classes and provide helper functions\r\n * to create and register them as singletons for tests.\r\n * \r\n * Key concepts:\r\n * - Mock singleton UCs extend the real UC classes\r\n * - They override methods with test implementations\r\n * - They register themselves as singletons just like the real UCs\r\n * - They include helper functions to create them in tests\r\n * \r\n * Usage pattern (in tests):\r\n * ```typescript\r\n * // In a test file\r\n * const mockUC = makeMockToggleExampleBooleanUC(appObject);\r\n * const spy = jest.spyOn(mockUC, 'toggleExampleBoolean');\r\n * \r\n * // Call the function that should use the UC\r\n * toggleExampleBoolean(appObjects);\r\n * \r\n * // Verify the UC method was called correctly\r\n * expect(spy).toHaveBeenCalled();\r\n * ```\r\n */\r\n\r\nimport { AppObject } from \"../../AppObject\";\r\nimport { ToggleExampleBooleanUC } from \"../UCs/ToggleExampleBooleanUC\";\r\n\r\n/**\r\n * Mock implementation of ToggleExampleBooleanUC for testing\r\n * Provides a no-op implementation of toggleExampleBoolean that can be spied on in tests\r\n */\r\nexport class MockToggleExampleBooleanUC extends ToggleExampleBooleanUC {\r\n  /**\r\n   * Mock implementation that does nothing\r\n   * In tests, this can be replaced with a Jest spy to track calls\r\n   */\r\n  toggleExampleBoolean = (): void => {};\r\n\r\n  constructor(appObject: AppObject) {\r\n    super(appObject, ToggleExampleBooleanUC.type);\r\n    // Register as a singleton just like the real UC\r\n    this.appObjects.registerSingleton(this);\r\n  }\r\n}\r\n\r\n/**\r\n * Helper factory function to create a mock ToggleExampleBooleanUC\r\n * @param appObject The AppObject to attach the UC to\r\n * @returns A new MockToggleExampleBooleanUC instance\r\n */\r\nexport function makeMockToggleExampleBooleanUC(\r\n  appObject: AppObject\r\n): MockToggleExampleBooleanUC {\r\n  return new MockToggleExampleBooleanUC(appObject);\r\n}\r\n"]}

package/dist/cjs/ExampleFeature/Mocks/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MockEditExampleStringUC"), exports);
+__exportStar(require("./MockExamplePM"), exports);
+__exportStar(require("./MockExampleSingletonPM"), exports);
+__exportStar(require("./MockToggleExampleBooleanUC"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/ExampleFeature/Mocks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/ExampleFeature/Mocks/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4DAA0C;AAC1C,kDAAgC;AAChC,2DAAyC;AACzC,+DAA6C","sourcesContent":["export * from \"./MockEditExampleStringUC\";\r\nexport * from \"./MockExamplePM\";\r\nexport * from \"./MockExampleSingletonPM\";\r\nexport * from \"./MockToggleExampleBooleanUC\";\r\n"]}

package/dist/cjs/ExampleFeature/PMs/ExamplePM.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExamplePM = void 0;
+exports.makeExamplePM = makeExamplePM;
+const AppObject_1 = require("../../AppObject");
+const ExampleEntity_1 = require("../Entities/ExampleEntity");
+/**
+ * ExamplePM transforms ExampleEntity data into a simple string view model.
+ * Abstract class provides the interface and static helper methods.
+ */
+class ExamplePM extends AppObject_1.AppObjectPM {
+    /**
+     * 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, appObjects) {
+        return appObjects.get(id)?.getComponent(ExamplePM.type);
+    }
+}
+exports.ExamplePM = ExamplePM;
+/** Unique type identifier for this component */
+ExamplePM.type = "ExamplePMType";
+/**
+ * Factory function to create a new ExamplePM
+ * @param appObject The AppObject to attach the PM to
+ * @returns A new ExamplePM instance
+ */
+function makeExamplePM(appObject) {
+    return new ExamplePMImp(appObject);
+}
+/**
+ * Concrete implementation of ExamplePM
+ * This private class handles the actual implementation details
+ */
+class ExamplePMImp extends ExamplePM {
+    /**
+     * Gets the ExampleEntity from the same AppObject
+     * Uses getCachedLocalComponent for efficient repeated access
+     */
+    get exampleEntity() {
+        return this.getCachedLocalComponent(ExampleEntity_1.ExampleEntity.type);
+    }
+    /**
+     * Compares two view models to determine if they're equal
+     * Used to avoid unnecessary view updates when values haven't changed
+     */
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+    constructor(appObject) {
+        super(appObject, ExamplePM.type);
+        /**
+         * Handler for entity change events
+         * Transforms entity data into a view model and updates views
+         */
+        this.onEntityChange = () => {
+            if (!this.exampleEntity)
+                return;
+            // In this simple case, our view model is just the string property value
+            this.doUpdateView(this.exampleEntity.aStringProperty);
+        };
+        /**
+         * Cleanup method called when the PM is being disposed
+         * Removes any observers to prevent memory leaks
+         */
+        this.dispose = () => {
+            super.dispose();
+            this.exampleEntity?.removeChangeObserver(this.onEntityChange);
+        };
+        // Register as an observer of the entity to receive change notifications
+        this.exampleEntity?.addChangeObserver(this.onEntityChange);
+        // Call the change handler initially to set up the initial view model
+        this.onEntityChange();
+    }
+}
+//# sourceMappingURL=ExamplePM.js.map

package/dist/cjs/ExampleFeature/PMs/ExamplePM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExamplePM.js","sourceRoot":"","sources":["../../../../src/ExampleFeature/PMs/ExamplePM.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;AA6BH,sCAEC;AA7BD,+CAAwE;AACxE,6DAA0D;AAE1D;;;GAGG;AACH,MAAsB,SAAU,SAAQ,uBAAmB;IAIzD;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CAAC,EAAU,EAAE,UAAyB;QAClD,OAAO,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,YAAY,CAAY,SAAS,CAAC,IAAI,CAAC,CAAC;IACrE,CAAC;;AAZH,8BAaC;AAZC,gDAAgD;AAChC,cAAI,GAAG,eAAe,CAAC;AAazC;;;;GAIG;AACH,SAAgB,aAAa,CAAC,SAAoB;IAChD,OAAO,IAAI,YAAY,CAAC,SAAS,CAAC,CAAC;AACrC,CAAC;AAED;;;GAGG;AACH,MAAM,YAAa,SAAQ,SAAS;IAClC;;;OAGG;IACH,IAAY,aAAa;QACvB,OAAO,IAAI,CAAC,uBAAuB,CAAgB,6BAAa,CAAC,IAAI,CAAC,CAAC;IACzE,CAAC;IAED;;;OAGG;IACH,WAAW,CAAC,CAAS,EAAE,CAAS;QAC9B,OAAO,CAAC,KAAK,CAAC,CAAC;IACjB,CAAC;IAsBD,YAAY,SAAoB;QAC9B,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QArBnC;;;WAGG;QACH,mBAAc,GAAG,GAAG,EAAE;YACpB,IAAI,CAAC,IAAI,CAAC,aAAa;gBAAE,OAAO;YAEhC,wEAAwE;YACxE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC;QACxD,CAAC,CAAC;QAEF;;;WAGG;QACH,YAAO,GAAG,GAAS,EAAE;YACnB,KAAK,CAAC,OAAO,EAAE,CAAC;YAChB,IAAI,CAAC,aAAa,EAAE,oBAAoB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAChE,CAAC,CAAC;QAKA,wEAAwE;QACxE,IAAI,CAAC,aAAa,EAAE,iBAAiB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAE3D,qEAAqE;QACrE,IAAI,CAAC,cAAc,EAAE,CAAC;IACxB,CAAC;CACF","sourcesContent":["/**\r\n * ExamplePM.ts\r\n * \r\n * This file demonstrates how to implement a Presentation Manager (PM) component.\r\n * PMs are responsible for transforming entity data into view models (VMs) for the UI.\r\n * They observe entities for changes and update their views when data changes.\r\n * \r\n * Key concepts:\r\n * - PMs extend AppObjectPM<VM> where VM is the view model type\r\n * - They observe entities and transform entity data into view models\r\n * - They notify UI components (views) when view models change\r\n * - Each PM instance is associated with a specific AppObject\r\n * \r\n * Usage pattern:\r\n * 1. Get a PM instance using getById\r\n * 2. Register UI components as views using addView(callback)\r\n * 3. PM will call the view callbacks with updated view models when entities change\r\n * 4. Remove UI components with removeView(callback) when they're unmounted\r\n */\r\n\r\nimport { AppObject, AppObjectPM, AppObjectRepo } from \"../../AppObject\";\r\nimport { ExampleEntity } from \"../Entities/ExampleEntity\";\r\n\r\n/**\r\n * ExamplePM transforms ExampleEntity data into a simple string view model.\r\n * Abstract class provides the interface and static helper methods.\r\n */\r\nexport abstract class ExamplePM extends AppObjectPM<string> {\r\n  /** Unique type identifier for this component */\r\n  static readonly type = \"ExamplePMType\";\r\n\r\n  /**\r\n   * Retrieves an ExamplePM by its parent AppObject's ID\r\n   * @param id The ID of the parent AppObject\r\n   * @param appObjects The AppObjectRepo to search in\r\n   * @returns The ExamplePM component or undefined if not found\r\n   */\r\n  static getById(id: string, appObjects: AppObjectRepo) {\r\n    return appObjects.get(id)?.getComponent<ExamplePM>(ExamplePM.type);\r\n  }\r\n}\r\n\r\n/**\r\n * Factory function to create a new ExamplePM\r\n * @param appObject The AppObject to attach the PM to\r\n * @returns A new ExamplePM instance\r\n */\r\nexport function makeExamplePM(appObject: AppObject): ExamplePM {\r\n  return new ExamplePMImp(appObject);\r\n}\r\n\r\n/**\r\n * Concrete implementation of ExamplePM\r\n * This private class handles the actual implementation details\r\n */\r\nclass ExamplePMImp extends ExamplePM {\r\n  /**\r\n   * Gets the ExampleEntity from the same AppObject\r\n   * Uses getCachedLocalComponent for efficient repeated access\r\n   */\r\n  private get exampleEntity() {\r\n    return this.getCachedLocalComponent<ExampleEntity>(ExampleEntity.type);\r\n  }\r\n\r\n  /**\r\n   * Compares two view models to determine if they're equal\r\n   * Used to avoid unnecessary view updates when values haven't changed\r\n   */\r\n  vmsAreEqual(a: string, b: string): boolean {\r\n    return a === b;\r\n  }\r\n\r\n  /**\r\n   * Handler for entity change events\r\n   * Transforms entity data into a view model and updates views\r\n   */\r\n  onEntityChange = () => {\r\n    if (!this.exampleEntity) return;\r\n\r\n    // In this simple case, our view model is just the string property value\r\n    this.doUpdateView(this.exampleEntity.aStringProperty);\r\n  };\r\n\r\n  /**\r\n   * Cleanup method called when the PM is being disposed\r\n   * Removes any observers to prevent memory leaks\r\n   */\r\n  dispose = (): void => {\r\n    super.dispose();\r\n    this.exampleEntity?.removeChangeObserver(this.onEntityChange);\r\n  };\r\n\r\n  constructor(appObject: AppObject) {\r\n    super(appObject, ExamplePM.type);\r\n\r\n    // Register as an observer of the entity to receive change notifications\r\n    this.exampleEntity?.addChangeObserver(this.onEntityChange);\r\n    \r\n    // Call the change handler initially to set up the initial view model\r\n    this.onEntityChange();\r\n  }\r\n}\r\n"]}

package/dist/cjs/ExampleFeature/PMs/ExampleSingletonPM.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSlideNavigationVM = exports.ExampleSingletonPM = void 0;
+exports.makeExampleSingletonPM = makeExampleSingletonPM;
+const AppObject_1 = require("../../AppObject");
+const getSingletonComponent_1 = require("../../AppObject/getSingletonComponent");
+const ExampleSingletonEntity_1 = require("../Entities/ExampleSingletonEntity");
+/**
+ * ExampleSingletonPM transforms SingletonEntityExample data into an ExampleVM.
+ * As a singleton, only one instance exists in the application.
+ */
+class ExampleSingletonPM extends AppObject_1.AppObjectPM {
+}
+exports.ExampleSingletonPM = ExampleSingletonPM;
+/** Unique type identifier for this component */
+ExampleSingletonPM.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
+ */
+ExampleSingletonPM.get = (appObjects) => (0, getSingletonComponent_1.getSingletonComponent)(ExampleSingletonPM.type, appObjects);
+/**
+ * Default view model used when no data is available
+ * UI components can use this initially or when the PM is not found
+ */
+exports.defaultSlideNavigationVM = {
+    aBoolProperty: true
+};
+/**
+ * Factory function to create a new ExampleSingletonPM
+ * @param appObject The AppObject to attach the PM to
+ * @returns A new ExampleSingletonPM instance
+ */
+function makeExampleSingletonPM(appObject) {
+    return new ExampleSingletonPMImp(appObject);
+}
+/**
+ * Concrete implementation of ExampleSingletonPM
+ * This private class handles the actual implementation details
+ */
+class ExampleSingletonPMImp extends ExampleSingletonPM {
+    /**
+     * Gets the SingletonEntityExample from the application
+     * Uses getCachedSingleton for efficient repeated access
+     */
+    get exampleEntity() {
+        return this.getCachedSingleton(ExampleSingletonEntity_1.SingletonEntityExample.type);
+    }
+    /**
+     * Compares two view models to determine if they're equal
+     * Used to avoid unnecessary view updates when values haven't changed
+     */
+    vmsAreEqual(a, b) {
+        if (a.aBoolProperty !== b.aBoolProperty)
+            return false;
+        return true;
+    }
+    constructor(appObject) {
+        super(appObject, ExampleSingletonPM.type);
+        /**
+         * Handler for entity change events
+         * Transforms entity data into a view model and updates views
+         */
+        this.onEntityChange = () => {
+            if (!this.exampleEntity)
+                return;
+            // Extract the boolean property from the entity
+            const aBoolProperty = this.exampleEntity.aBoolProperty;
+            // Create a view model with the extracted data
+            const vm = { aBoolProperty };
+            // Update all registered views with the new view model
+            this.doUpdateView(vm);
+        };
+        // Register as an observer of the entity to receive change notifications
+        this.exampleEntity?.addChangeObserver(this.onEntityChange);
+        // Call the change handler initially to set up the initial view model
+        this.onEntityChange();
+        // Register this PM as a singleton so it can be accessed globally
+        this.appObjects.registerSingleton(this);
+    }
+}
+//# sourceMappingURL=ExampleSingletonPM.js.map

package/dist/cjs/ExampleFeature/PMs/ExampleSingletonPM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExampleSingletonPM.js","sourceRoot":"","sources":["../../../../src/ExampleFeature/PMs/ExampleSingletonPM.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;AA+CH,wDAIC;AAjDD,+CAIyB;AACzB,iFAA8E;AAC9E,+EAA4E;AAS5E;;;GAGG;AACH,MAAsB,kBAAmB,SAAQ,uBAAsB;;AAAvE,gDAWC;AAVC,gDAAgD;AAChC,uBAAI,GAAG,wBAAwB,CAAC;AAEhD;;;;GAIG;AACI,sBAAG,GAAG,CAAC,UAAyB,EAAkC,EAAE,CACzE,IAAA,6CAAqB,EAAC,kBAAkB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;AAG/D;;;GAGG;AACU,QAAA,wBAAwB,GAAc;IACjD,aAAa,EAAE,IAAI;CACpB,CAAC;AAEF;;;;GAIG;AACH,SAAgB,sBAAsB,CACpC,SAAoB;IAEpB,OAAO,IAAI,qBAAqB,CAAC,SAAS,CAAC,CAAC;AAC9C,CAAC;AAED;;;GAGG;AACH,MAAM,qBAAsB,SAAQ,kBAAkB;IACpD;;;OAGG;IACH,IAAY,aAAa;QACvB,OAAO,IAAI,CAAC,kBAAkB,CAC5B,+CAAsB,CAAC,IAAI,CAC5B,CAAC;IACJ,CAAC;IAmBD;;;OAGG;IACH,WAAW,CAAC,CAAY,EAAE,CAAY;QACpC,IAAI,CAAC,CAAC,aAAa,KAAK,CAAC,CAAC,aAAa;YAAE,OAAO,KAAK,CAAC;QACtD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,YAAY,SAAoB;QAC9B,KAAK,CAAC,SAAS,EAAE,kBAAkB,CAAC,IAAI,CAAC,CAAC;QA3B5C;;;WAGG;QACH,mBAAc,GAAG,GAAG,EAAE;YACpB,IAAI,CAAC,IAAI,CAAC,aAAa;gBAAE,OAAO;YAEhC,+CAA+C;YAC/C,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC;YAEvD,8CAA8C;YAC9C,MAAM,EAAE,GAAG,EAAE,aAAa,EAAE,CAAC;YAE7B,sDAAsD;YACtD,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;QACxB,CAAC,CAAC;QAcA,wEAAwE;QACxE,IAAI,CAAC,aAAa,EAAE,iBAAiB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAE3D,qEAAqE;QACrE,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,iEAAiE;QACjE,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;CACF","sourcesContent":["/**\r\n * ExampleSingletonPM.ts\r\n * \r\n * This file demonstrates how to implement a Singleton Presentation Manager (PM).\r\n * Singleton PMs are special PMs that exist only once in the application and can be\r\n * accessed globally. They transform data from singleton entities into view models.\r\n * \r\n * Key concepts:\r\n * - Singleton PMs extend AppObjectPM<VM> like regular PMs\r\n * - They register themselves as singletons with appObjects.registerSingleton()\r\n * - They're accessed through a static get() method using getSingletonComponent()\r\n * - They typically observe singleton entities and provide data to multiple UI components\r\n * \r\n * Usage pattern:\r\n * 1. Access the singleton PM using the static get() method\r\n * 2. Register UI components as views using addView(callback)\r\n * 3. PM will call the view callbacks with updated view models when entities change\r\n * 4. Remove UI components with removeView(callback) when they're unmounted\r\n */\r\n\r\nimport {\r\n  AppObject,\r\n  AppObjectPM,\r\n  AppObjectRepo,\r\n} from \"../../AppObject\";\r\nimport { getSingletonComponent } from \"../../AppObject/getSingletonComponent\";\r\nimport { SingletonEntityExample } from \"../Entities/ExampleSingletonEntity\";\r\n\r\n/**\r\n * Interface defining the structure of the view model provided by ExampleSingletonPM\r\n */\r\nexport interface ExampleVM {\r\n  aBoolProperty: boolean;\r\n}\r\n\r\n/**\r\n * ExampleSingletonPM transforms SingletonEntityExample data into an ExampleVM.\r\n * As a singleton, only one instance exists in the application.\r\n */\r\nexport abstract class ExampleSingletonPM extends AppObjectPM<ExampleVM> {\r\n  /** Unique type identifier for this component */\r\n  static readonly type = \"ExampleSingletonPMType\";\r\n\r\n  /**\r\n   * Global accessor for the singleton PM\r\n   * @param appObjects The AppObjectRepo to search in\r\n   * @returns The singleton PM or undefined if not created yet\r\n   */\r\n  static get = (appObjects: AppObjectRepo): ExampleSingletonPM | undefined =>\r\n    getSingletonComponent(ExampleSingletonPM.type, appObjects);\r\n}\r\n\r\n/**\r\n * Default view model used when no data is available\r\n * UI components can use this initially or when the PM is not found\r\n */\r\nexport const defaultSlideNavigationVM: ExampleVM = {\r\n  aBoolProperty: true\r\n};\r\n\r\n/**\r\n * Factory function to create a new ExampleSingletonPM\r\n * @param appObject The AppObject to attach the PM to\r\n * @returns A new ExampleSingletonPM instance\r\n */\r\nexport function makeExampleSingletonPM(\r\n  appObject: AppObject\r\n): ExampleSingletonPM {\r\n  return new ExampleSingletonPMImp(appObject);\r\n}\r\n\r\n/**\r\n * Concrete implementation of ExampleSingletonPM\r\n * This private class handles the actual implementation details\r\n */\r\nclass ExampleSingletonPMImp extends ExampleSingletonPM {\r\n  /**\r\n   * Gets the SingletonEntityExample from the application\r\n   * Uses getCachedSingleton for efficient repeated access\r\n   */\r\n  private get exampleEntity() {\r\n    return this.getCachedSingleton<SingletonEntityExample>(\r\n      SingletonEntityExample.type\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Handler for entity change events\r\n   * Transforms entity data into a view model and updates views\r\n   */\r\n  onEntityChange = () => {\r\n    if (!this.exampleEntity) return;\r\n\r\n    // Extract the boolean property from the entity\r\n    const aBoolProperty = this.exampleEntity.aBoolProperty;\r\n\r\n    // Create a view model with the extracted data\r\n    const vm = { aBoolProperty };\r\n\r\n    // Update all registered views with the new view model\r\n    this.doUpdateView(vm);\r\n  };\r\n\r\n  /**\r\n   * Compares two view models to determine if they're equal\r\n   * Used to avoid unnecessary view updates when values haven't changed\r\n   */\r\n  vmsAreEqual(a: ExampleVM, b: ExampleVM): boolean {\r\n    if (a.aBoolProperty !== b.aBoolProperty) return false;\r\n    return true;\r\n  }\r\n\r\n  constructor(appObject: AppObject) {\r\n    super(appObject, ExampleSingletonPM.type);\r\n\r\n    // Register as an observer of the entity to receive change notifications\r\n    this.exampleEntity?.addChangeObserver(this.onEntityChange);\r\n    \r\n    // Call the change handler initially to set up the initial view model\r\n    this.onEntityChange();\r\n    \r\n    // Register this PM as a singleton so it can be accessed globally\r\n    this.appObjects.registerSingleton(this);\r\n  }\r\n}\r\n"]}

package/dist/cjs/ExampleFeature/PMs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ExamplePM"), exports);
+__exportStar(require("./ExampleSingletonPM"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/ExampleFeature/PMs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/ExampleFeature/PMs/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B;AAC5B,uDAAqC","sourcesContent":["export * from \"./ExamplePM\";\r\nexport * from \"./ExampleSingletonPM\";\r\n"]}