@onerjs/shared-ui-components 8.48.4 → 8.48.5

package/modularTool/components/uxContextProvider.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { ToolContext } from "../../fluent/hoc/fluentToolWrapper.js";
+import { useSetting } from "../hooks/settingsHooks.js";
+import { CompactModeSettingDescriptor, DisableCopySettingDescriptor } from "../services/globalSettings.js";
+export const UXContextProvider = (props) => {
+    const [compactMode] = useSetting(CompactModeSettingDescriptor);
+    const [disableCopy] = useSetting(DisableCopySettingDescriptor);
+    const toolsContext = useMemo(() => {
+        return {
+            toolName: "",
+            size: compactMode ? "small" : "medium",
+            disableCopy,
+            useFluent: true,
+        };
+    }, [compactMode, disableCopy]);
+    return _jsx(ToolContext.Provider, { value: toolsContext, children: props.children });
+};
+//# sourceMappingURL=uxContextProvider.js.map

package/modularTool/components/uxContextProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uxContextProvider.js","sourceRoot":"","sources":["../../../../../dev/sharedUiComponents/src/modularTool/components/uxContextProvider.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAoE,OAAO,EAAE,MAAM,OAAO,CAAC;AAElG,OAAO,EAAE,WAAW,EAAE,MAAM,mDAAmD,CAAC;AAChF,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,4BAA4B,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAC;AAExG,MAAM,CAAC,MAAM,iBAAiB,GAAyC,CAAC,KAAK,EAAE,EAAE;IAC7E,MAAM,CAAC,WAAW,CAAC,GAAG,UAAU,CAAC,4BAA4B,CAAC,CAAC;IAC/D,MAAM,CAAC,WAAW,CAAC,GAAG,UAAU,CAAC,4BAA4B,CAAC,CAAC;IAE/D,MAAM,YAAY,GAAG,OAAO,CAAC,GAAG,EAAE;QAC9B,OAAO;YACH,QAAQ,EAAE,EAAE;YACZ,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ;YACtC,WAAW;YACX,SAAS,EAAE,IAAI;SACwB,CAAC;IAChD,CAAC,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC;IAE/B,OAAO,KAAC,WAAW,CAAC,QAAQ,IAAC,KAAK,EAAE,YAAY,YAAG,KAAK,CAAC,QAAQ,GAAwB,CAAC;AAC9F,CAAC,CAAC","sourcesContent":["import { type ContextType, type FunctionComponent, type PropsWithChildren, useMemo } from \"react\";\r\n\r\nimport { ToolContext } from \"shared-ui-components/fluent/hoc/fluentToolWrapper\";\r\nimport { useSetting } from \"../hooks/settingsHooks\";\r\nimport { CompactModeSettingDescriptor, DisableCopySettingDescriptor } from \"../services/globalSettings\";\r\n\r\nexport const UXContextProvider: FunctionComponent<PropsWithChildren> = (props) => {\r\n    const [compactMode] = useSetting(CompactModeSettingDescriptor);\r\n    const [disableCopy] = useSetting(DisableCopySettingDescriptor);\r\n\r\n    const toolsContext = useMemo(() => {\r\n        return {\r\n            toolName: \"\",\r\n            size: compactMode ? \"small\" : \"medium\",\r\n            disableCopy,\r\n            useFluent: true,\r\n        } satisfies ContextType<typeof ToolContext>;\r\n    }, [compactMode, disableCopy]);\r\n\r\n    return <ToolContext.Provider value={toolsContext}>{props.children}</ToolContext.Provider>;\r\n};\r\n"]}

package/modularTool/contexts/extensionManagerContext.d.ts

@@ -0,0 +1,6 @@
+import { type ExtensionManager } from "../extensibility/extensionManager.js";
+export type ExtensionManagerContext = {
+    readonly extensionManager: ExtensionManager;
+};
+export declare const ExtensionManagerContext: import("react").Context<ExtensionManagerContext | undefined>;
+export declare function useExtensionManager(): ExtensionManager | undefined;

package/modularTool/contexts/extensionManagerContext.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from "react";
+export const ExtensionManagerContext = createContext(undefined);
+export function useExtensionManager() {
+    return useContext(ExtensionManagerContext)?.extensionManager;
+}
+//# sourceMappingURL=extensionManagerContext.js.map

package/modularTool/contexts/extensionManagerContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensionManagerContext.js","sourceRoot":"","sources":["../../../../../dev/sharedUiComponents/src/modularTool/contexts/extensionManagerContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAMlD,MAAM,CAAC,MAAM,uBAAuB,GAAG,aAAa,CAAsC,SAAS,CAAC,CAAC;AAErG,MAAM,UAAU,mBAAmB;IAC/B,OAAO,UAAU,CAAC,uBAAuB,CAAC,EAAE,gBAAgB,CAAC;AACjE,CAAC","sourcesContent":["import { type ExtensionManager } from \"../extensibility/extensionManager\";\r\n\r\nimport { createContext, useContext } from \"react\";\r\n\r\nexport type ExtensionManagerContext = {\r\n    readonly extensionManager: ExtensionManager;\r\n};\r\n\r\nexport const ExtensionManagerContext = createContext<ExtensionManagerContext | undefined>(undefined);\r\n\r\nexport function useExtensionManager() {\r\n    return useContext(ExtensionManagerContext)?.extensionManager;\r\n}\r\n"]}

package/modularTool/contexts/settingsContext.d.ts

@@ -0,0 +1,3 @@
+import { type ISettingsStore } from "../services/settingsStore.js";
+export declare const SettingsStoreContext: import("react").Context<ISettingsStore | undefined>;
+export declare function useSettingsStore(): ISettingsStore | undefined;

package/modularTool/contexts/settingsContext.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from "react";
+export const SettingsStoreContext = createContext(undefined);
+export function useSettingsStore() {
+    return useContext(SettingsStoreContext);
+}
+//# sourceMappingURL=settingsContext.js.map

package/modularTool/contexts/settingsContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settingsContext.js","sourceRoot":"","sources":["../../../../../dev/sharedUiComponents/src/modularTool/contexts/settingsContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAElD,MAAM,CAAC,MAAM,oBAAoB,GAAG,aAAa,CAA6B,SAAS,CAAC,CAAC;AAEzF,MAAM,UAAU,gBAAgB;IAC5B,OAAO,UAAU,CAAC,oBAAoB,CAAC,CAAC;AAC5C,CAAC","sourcesContent":["import { type ISettingsStore } from \"../services/settingsStore\";\r\n\r\nimport { createContext, useContext } from \"react\";\r\n\r\nexport const SettingsStoreContext = createContext<ISettingsStore | undefined>(undefined);\r\n\r\nexport function useSettingsStore() {\r\n    return useContext(SettingsStoreContext);\r\n}\r\n"]}

package/modularTool/extensibility/builtInsExtensionFeed.d.ts

@@ -0,0 +1,21 @@
+import { type IExtensionFeed, type ExtensionMetadata, type IExtensionMetadataQuery, type ExtensionModule } from "./extensionFeed.js";
+export type BuiltInExtension = ExtensionMetadata & {
+    /**
+     * Gets the extension module, typically dynamically importing the extension.
+     * @returns The extension module (e.g. a collection of ServiceDefinitions).
+     */
+    getExtensionModuleAsync(): Promise<ExtensionModule>;
+};
+/**
+ * A simple extension feed implementation that provides a fixed set of "built in" extensions.
+ * "Built in" in this context means extensions that are known at bundling time, and included
+ * in the bundle. Each extension can be dynamically imported so they are split into separate
+ * bundle chunks and downloaded only when first installed.
+ */
+export declare class BuiltInsExtensionFeed implements IExtensionFeed {
+    readonly name: string;
+    private readonly _extensions;
+    constructor(name: string, extensions: Iterable<BuiltInExtension>);
+    queryExtensionsAsync(filter?: string): Promise<IExtensionMetadataQuery>;
+    getExtensionModuleAsync(name: string): Promise<ExtensionModule | undefined>;
+}

package/modularTool/extensibility/builtInsExtensionFeed.js

@@ -0,0 +1,26 @@
+/**
+ * A simple extension feed implementation that provides a fixed set of "built in" extensions.
+ * "Built in" in this context means extensions that are known at bundling time, and included
+ * in the bundle. Each extension can be dynamically imported so they are split into separate
+ * bundle chunks and downloaded only when first installed.
+ */
+export class BuiltInsExtensionFeed {
+    constructor(name, extensions) {
+        this.name = name;
+        this._extensions = Array.from(extensions);
+    }
+    async queryExtensionsAsync(filter) {
+        const filteredExtensions = filter ? this._extensions.filter((extension) => extension.name.includes(filter)) : this._extensions;
+        return {
+            totalCount: filteredExtensions.length,
+            getExtensionMetadataAsync: async (index, count) => {
+                return filteredExtensions.slice(index, index + count);
+            },
+        };
+    }
+    async getExtensionModuleAsync(name) {
+        const extension = this._extensions.find((ext) => ext.name === name);
+        return extension ? await extension.getExtensionModuleAsync() : undefined;
+    }
+}
+//# sourceMappingURL=builtInsExtensionFeed.js.map

package/modularTool/extensibility/builtInsExtensionFeed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtInsExtensionFeed.js","sourceRoot":"","sources":["../../../../../dev/sharedUiComponents/src/modularTool/extensibility/builtInsExtensionFeed.ts"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,MAAM,OAAO,qBAAqB;IAG9B,YACoB,IAAY,EAC5B,UAAsC;QADtB,SAAI,GAAJ,IAAI,CAAQ;QAG5B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC9C,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAAC,MAAe;QAC7C,MAAM,kBAAkB,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC;QAC/H,OAAO;YACH,UAAU,EAAE,kBAAkB,CAAC,MAAM;YACrC,yBAAyB,EAAE,KAAK,EAAE,KAAa,EAAE,KAAa,EAAE,EAAE;gBAC9D,OAAO,kBAAkB,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC;YAC1D,CAAC;SACJ,CAAC;IACN,CAAC;IAEM,KAAK,CAAC,uBAAuB,CAAC,IAAY;QAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QACpE,OAAO,SAAS,CAAC,CAAC,CAAC,MAAM,SAAS,CAAC,uBAAuB,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7E,CAAC;CACJ","sourcesContent":["import { type IExtensionFeed, type ExtensionMetadata, type IExtensionMetadataQuery, type ExtensionModule } from \"./extensionFeed\";\r\n\r\nexport type BuiltInExtension = ExtensionMetadata & {\r\n    /**\r\n     * Gets the extension module, typically dynamically importing the extension.\r\n     * @returns The extension module (e.g. a collection of ServiceDefinitions).\r\n     */\r\n    getExtensionModuleAsync(): Promise<ExtensionModule>;\r\n};\r\n\r\n/**\r\n * A simple extension feed implementation that provides a fixed set of \"built in\" extensions.\r\n * \"Built in\" in this context means extensions that are known at bundling time, and included\r\n * in the bundle. Each extension can be dynamically imported so they are split into separate\r\n * bundle chunks and downloaded only when first installed.\r\n */\r\nexport class BuiltInsExtensionFeed implements IExtensionFeed {\r\n    private readonly _extensions: readonly BuiltInExtension[];\r\n\r\n    public constructor(\r\n        public readonly name: string,\r\n        extensions: Iterable<BuiltInExtension>\r\n    ) {\r\n        this._extensions = Array.from(extensions);\r\n    }\r\n\r\n    public async queryExtensionsAsync(filter?: string): Promise<IExtensionMetadataQuery> {\r\n        const filteredExtensions = filter ? this._extensions.filter((extension) => extension.name.includes(filter)) : this._extensions;\r\n        return {\r\n            totalCount: filteredExtensions.length,\r\n            getExtensionMetadataAsync: async (index: number, count: number) => {\r\n                return filteredExtensions.slice(index, index + count);\r\n            },\r\n        };\r\n    }\r\n\r\n    public async getExtensionModuleAsync(name: string): Promise<ExtensionModule | undefined> {\r\n        const extension = this._extensions.find((ext) => ext.name === name);\r\n        return extension ? await extension.getExtensionModuleAsync() : undefined;\r\n    }\r\n}\r\n"]}

package/modularTool/extensibility/extensionFeed.d.ts

@@ -0,0 +1,113 @@
+import { type WeaklyTypedServiceDefinition } from "../modularity/serviceContainer.js";
+export type PersonMetadata = {
+    /**
+     * The name of the person.
+     */
+    readonly name: string;
+    /**
+     * The email address of the person.
+     */
+    readonly email?: string;
+    /**
+     * The URL to the person's website.
+     */
+    readonly url?: string;
+    /**
+     * The Babylon forum username of the person.
+     */
+    readonly forumUserName?: string;
+    /**
+     * A base64 encoded PNG image to use as the person's avatar.
+     */
+    readonly avatar?: string;
+};
+export type ExtensionMetadata = {
+    /**
+     * The name of the extension.
+     */
+    readonly name: string;
+    /**
+     * The version of the extension (as valid semver).
+     */
+    readonly version?: string;
+    /**
+     * The description of the extension.
+     */
+    readonly description: string;
+    /**
+     * The keywords of the extension.
+     */
+    readonly keywords?: readonly string[];
+    /**
+     * The URL to the extension homepage.
+     */
+    readonly homepage?: string;
+    /**
+     * Specify the place where your code lives. This is helpful for people who want to contribute.
+     */
+    readonly repository?: string;
+    /**
+     * The URL to your extension's issue tracker and / or the email address to which issues should be reported. These are helpful for people who encounter issues with your extension.
+     */
+    readonly bugs?: string;
+    /**
+     * A license for your package so that people know how they are permitted to use it, and any restrictions you're placing on it.
+     */
+    readonly license?: string;
+    /**
+     * The primary author of the extension.
+     */
+    readonly author?: string | PersonMetadata;
+    /**
+     * The contributors to the extension.
+     */
+    readonly contributors?: readonly (string | PersonMetadata)[];
+};
+export type ExtensionModule = {
+    /**
+     * The default export of the module (e.g. export default).
+     */
+    default: {
+        /**
+         * The services that are included with the extension.
+         */
+        serviceDefinitions?: readonly WeaklyTypedServiceDefinition[];
+    };
+};
+/**
+ * Represents a query to fetch subset ranges of extension metadata from a feed.
+ */
+export interface IExtensionMetadataQuery {
+    /**
+     * The total number of extensions that satisfy the query.
+     */
+    readonly totalCount: number;
+    /**
+     * Fetches a range of extension metadata from the feed.
+     * @param index The index of the first extension to fetch.
+     * @param count The number of extensions to fetch.
+     * @returns A promise that resolves to the extension metadata.
+     */
+    getExtensionMetadataAsync(index: number, count: number): Promise<readonly ExtensionMetadata[]>;
+}
+/**
+ * Represents a feed/source of extensions.
+ */
+export interface IExtensionFeed {
+    /**
+     * The name of the feed.
+     */
+    readonly name: string;
+    /**
+     * Creates an extension metadata query given a filter.
+     * @param filter The filter to apply to the query.
+     * @returns A promise that resolves to the extension metadata query.
+     */
+    queryExtensionsAsync(filter?: string): Promise<IExtensionMetadataQuery>;
+    /**
+     * Gets the extension module for the specified extension.
+     * @param name The name of the extension.
+     * @returns A promise that resolves to the extension module.
+     */
+    getExtensionModuleAsync(name: string): Promise<ExtensionModule | undefined>;
+}

package/modularTool/extensibility/extensionFeed.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=extensionFeed.js.map

package/modularTool/extensibility/extensionFeed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensionFeed.js","sourceRoot":"","sources":["../../../../../dev/sharedUiComponents/src/modularTool/extensibility/extensionFeed.ts"],"names":[],"mappings":"","sourcesContent":["import { type WeaklyTypedServiceDefinition } from \"../modularity/serviceContainer\";\r\n\r\nexport type PersonMetadata = {\r\n    /**\r\n     * The name of the person.\r\n     */\r\n    readonly name: string;\r\n\r\n    /**\r\n     * The email address of the person.\r\n     */\r\n    readonly email?: string;\r\n\r\n    /**\r\n     * The URL to the person's website.\r\n     */\r\n    readonly url?: string;\r\n\r\n    /**\r\n     * The Babylon forum username of the person.\r\n     */\r\n    readonly forumUserName?: string;\r\n\r\n    /**\r\n     * A base64 encoded PNG image to use as the person's avatar.\r\n     */\r\n    readonly avatar?: string;\r\n};\r\n\r\nexport type ExtensionMetadata = {\r\n    /**\r\n     * The name of the extension.\r\n     */\r\n    readonly name: string;\r\n\r\n    /**\r\n     * The version of the extension (as valid semver).\r\n     */\r\n    readonly version?: string;\r\n\r\n    /**\r\n     * The description of the extension.\r\n     */\r\n    readonly description: string;\r\n\r\n    /**\r\n     * The keywords of the extension.\r\n     */\r\n    readonly keywords?: readonly string[];\r\n\r\n    /**\r\n     * The URL to the extension homepage.\r\n     */\r\n    readonly homepage?: string;\r\n\r\n    /**\r\n     * Specify the place where your code lives. This is helpful for people who want to contribute.\r\n     */\r\n    readonly repository?: string;\r\n\r\n    /**\r\n     * The URL to your extension's issue tracker and / or the email address to which issues should be reported. These are helpful for people who encounter issues with your extension.\r\n     */\r\n    readonly bugs?: string;\r\n\r\n    /**\r\n     * A license for your package so that people know how they are permitted to use it, and any restrictions you're placing on it.\r\n     */\r\n    readonly license?: string;\r\n\r\n    /**\r\n     * The primary author of the extension.\r\n     */\r\n    readonly author?: string | PersonMetadata;\r\n\r\n    /**\r\n     * The contributors to the extension.\r\n     */\r\n    readonly contributors?: readonly (string | PersonMetadata)[];\r\n};\r\n\r\nexport type ExtensionModule = {\r\n    /**\r\n     * The default export of the module (e.g. export default).\r\n     */\r\n    default: {\r\n        /**\r\n         * The services that are included with the extension.\r\n         */\r\n        serviceDefinitions?: readonly WeaklyTypedServiceDefinition[];\r\n    };\r\n};\r\n\r\n/**\r\n * Represents a query to fetch subset ranges of extension metadata from a feed.\r\n */\r\nexport interface IExtensionMetadataQuery {\r\n    /**\r\n     * The total number of extensions that satisfy the query.\r\n     */\r\n    readonly totalCount: number;\r\n\r\n    /**\r\n     * Fetches a range of extension metadata from the feed.\r\n     * @param index The index of the first extension to fetch.\r\n     * @param count The number of extensions to fetch.\r\n     * @returns A promise that resolves to the extension metadata.\r\n     */\r\n    getExtensionMetadataAsync(index: number, count: number): Promise<readonly ExtensionMetadata[]>;\r\n}\r\n\r\n/**\r\n * Represents a feed/source of extensions.\r\n */\r\nexport interface IExtensionFeed {\r\n    /**\r\n     * The name of the feed.\r\n     */\r\n    readonly name: string;\r\n\r\n    /**\r\n     * Creates an extension metadata query given a filter.\r\n     * @param filter The filter to apply to the query.\r\n     * @returns A promise that resolves to the extension metadata query.\r\n     */\r\n    queryExtensionsAsync(filter?: string): Promise<IExtensionMetadataQuery>;\r\n\r\n    /**\r\n     * Gets the extension module for the specified extension.\r\n     * @param name The name of the extension.\r\n     * @returns A promise that resolves to the extension module.\r\n     */\r\n    getExtensionModuleAsync(name: string): Promise<ExtensionModule | undefined>;\r\n}\r\n"]}

package/modularTool/extensibility/extensionManager.d.ts

@@ -0,0 +1,111 @@
+import { type IDisposable } from "@onerjs/core/index.js";
+import { type ServiceContainer } from "../modularity/serviceContainer.js";
+import { type IExtensionFeed, type ExtensionMetadata } from "./extensionFeed.js";
+/**
+ * Represents a loaded extension.
+ */
+export interface IExtension {
+    /**
+     * The metadata for the extension.
+     */
+    readonly metadata: ExtensionMetadata;
+    /**
+     * Whether the extension is currently being installed, uninstalled, enabled, or disabled.
+     */
+    readonly isStateChanging: boolean;
+    /**
+     * Whether the extension is enabled.
+     */
+    readonly isInstalled: boolean;
+    /**
+     * Installs the extension.
+     */
+    installAsync(): Promise<void>;
+    /**
+     * Uninstalls the extension.
+     */
+    uninstallAsync(): Promise<void>;
+    /**
+     * Adds a handler that is called when the state of the extension changes.
+     * @param handler The handler to add.
+     * @returns A disposable that removes the handler when disposed.
+     */
+    addStateChangedHandler(handler: () => void): IDisposable;
+}
+/**
+ * Provides information about an extension installation failure.
+ */
+export type InstallFailedInfo = {
+    /**
+     * The metadata of the extension that failed to install.
+     */
+    extension: ExtensionMetadata;
+    /**
+     * The error that occurred during the installation.
+     */
+    error: unknown;
+};
+/**
+ * Represents a query for loaded extensions.
+ */
+export interface IExtensionQuery {
+    /**
+     * The total number of extensions that satisfy the query.
+     */
+    readonly totalCount: number;
+    /**
+     * Fetches a range of extensions from the query.
+     * @param index The index of the first extension to fetch.
+     * @param count The number of extensions to fetch.
+     * @returns A promise that resolves to the extensions.
+     */
+    getExtensionsAsync(index: number, count: number): Promise<IExtension[]>;
+}
+/**
+ * Manages the installation, uninstallation, enabling, and disabling of extensions.
+ */
+export declare class ExtensionManager implements IDisposable {
+    private readonly _namespace;
+    private readonly _serviceContainer;
+    private readonly _feeds;
+    private readonly _onInstallFailed;
+    private readonly _installedExtensions;
+    private readonly _stateChangedHandlers;
+    private constructor();
+    /**
+     * Creates a new instance of the ExtensionManager.
+     * This will automatically rehydrate previously installed and enabled extensions.
+     * @param namespace The namespace to use for storing extension state in local storage.
+     * @param serviceContainer The service container to use.
+     * @param feeds The extension feeds to include.
+     * @param onInstallFailed A callback that is called when an extension installation fails.
+     * @returns A promise that resolves to the new instance of the ExtensionManager.
+     */
+    static CreateAsync(namespace: string, serviceContainer: ServiceContainer, feeds: readonly IExtensionFeed[], onInstallFailed: (info: InstallFailedInfo) => void): Promise<ExtensionManager>;
+    /**
+     * Gets the names of the feeds that are included in the extension manager.
+     * @returns The names of the feeds.
+     */
+    get feedNames(): string[];
+    /**
+     * Queries the extension manager for extensions.
+     * @param filter The filter to apply to the query.
+     * @param feeds The feeds to include in the query.
+     * @param installedOnly Whether to only include installed extensions.
+     * @returns A promise that resolves to the extension query.
+     */
+    queryExtensionsAsync(filter?: string, feeds?: string[], installedOnly?: boolean): Promise<IExtensionQuery>;
+    /**
+     * Disposes the extension manager.
+     */
+    dispose(): void;
+    private _getInstalledExtensionStorageKey;
+    private _updateInstalledExtensionsStorage;
+    private _installAsync;
+    private _uninstallAsync;
+    private _enableAsync;
+    private _disableAsync;
+    private _addStateChangedHandler;
+    private _createExtension;
+    private _createInstalledExtension;
+}

package/modularTool/extensibility/extensionManager.js

@@ -0,0 +1,277 @@
+import { Logger } from "@onerjs/core/Misc/logger.js";
+const InstalledExtensionsKey = "Extensions/InstalledExtensions";
+const ExtensionInstalledKeyPrefix = "Extensions/IsExtensionInstalled";
+function GetExtensionInstalledKey(name) {
+    return `${ExtensionInstalledKeyPrefix}/${name}`;
+}
+function GetExtensionIdentity(feed, name) {
+    return `${feed}/${name}`;
+}
+/**
+ * Manages the installation, uninstallation, enabling, and disabling of extensions.
+ */
+export class ExtensionManager {
+    constructor(_namespace, _serviceContainer, _feeds, _onInstallFailed) {
+        this._namespace = _namespace;
+        this._serviceContainer = _serviceContainer;
+        this._feeds = _feeds;
+        this._onInstallFailed = _onInstallFailed;
+        this._installedExtensions = new Map();
+        this._stateChangedHandlers = new Map();
+    }
+    /**
+     * Creates a new instance of the ExtensionManager.
+     * This will automatically rehydrate previously installed and enabled extensions.
+     * @param namespace The namespace to use for storing extension state in local storage.
+     * @param serviceContainer The service container to use.
+     * @param feeds The extension feeds to include.
+     * @param onInstallFailed A callback that is called when an extension installation fails.
+     * @returns A promise that resolves to the new instance of the ExtensionManager.
+     */
+    static async CreateAsync(namespace, serviceContainer, feeds, onInstallFailed) {
+        namespace = `Babylon/${namespace}`;
+        const extensionManager = new ExtensionManager(namespace, serviceContainer, feeds, onInstallFailed);
+        // Rehydrate installed extensions.
+        const installedExtensionNames = JSON.parse(localStorage.getItem(`${namespace}/${InstalledExtensionsKey}`) ?? "[]");
+        for (const installedExtensionName of installedExtensionNames) {
+            const installedExtensionRaw = localStorage.getItem(`${namespace}/${GetExtensionInstalledKey(installedExtensionName)}`);
+            if (installedExtensionRaw) {
+                const installedExtensionData = JSON.parse(installedExtensionRaw);
+                const feed = feeds.find((feed) => feed.name === installedExtensionData.feed);
+                if (feed) {
+                    const installedExtension = extensionManager._createInstalledExtension(installedExtensionData.metadata, feed);
+                    extensionManager._installedExtensions.set(installedExtension.metadata.name, installedExtension);
+                }
+            }
+        }
+        // Load installed and enabled extensions.
+        const enablePromises = [];
+        for (const extension of extensionManager._installedExtensions.values()) {
+            enablePromises.push((async () => {
+                try {
+                    await extensionManager._enableAsync(extension.metadata, false, false);
+                }
+                catch {
+                    // If enabling the extension fails, uninstall it. The extension install fail callback will still be called,
+                    // so the owner of the ExtensionManager instance can decide what to do with the error.
+                    await extensionManager._uninstallAsync(extension.metadata, false);
+                }
+            })());
+        }
+        await Promise.all(enablePromises);
+        return extensionManager;
+    }
+    /**
+     * Gets the names of the feeds that are included in the extension manager.
+     * @returns The names of the feeds.
+     */
+    get feedNames() {
+        return this._feeds.map((feed) => feed.name);
+    }
+    /**
+     * Queries the extension manager for extensions.
+     * @param filter The filter to apply to the query.
+     * @param feeds The feeds to include in the query.
+     * @param installedOnly Whether to only include installed extensions.
+     * @returns A promise that resolves to the extension query.
+     */
+    async queryExtensionsAsync(filter = "", feeds = this.feedNames, installedOnly = false) {
+        if (installedOnly) {
+            const installedExtensions = Array.from(this._installedExtensions.values()).filter((installedExtension) => feeds.includes(installedExtension.feed.name));
+            return {
+                totalCount: installedExtensions.length,
+                getExtensionsAsync: async (index, count) => {
+                    return installedExtensions.slice(index, index + count).map((installedExtension) => this._createExtension(installedExtension.metadata, installedExtension.feed));
+                },
+            };
+        }
+        const queries = await Promise.all(this._feeds.filter((feed) => feeds.includes(feed.name)).map(async (feed) => Object.assign(await feed.queryExtensionsAsync(filter), { feed })));
+        const totalCount = queries.reduce((sum, query) => sum + query.totalCount, 0);
+        return {
+            totalCount,
+            getExtensionsAsync: async (index, count) => {
+                const extensions = new Array();
+                let remaining = count;
+                for (const query of queries) {
+                    if (remaining <= 0) {
+                        break;
+                    }
+                    if (index >= query.totalCount) {
+                        index -= query.totalCount;
+                        continue;
+                    }
+                    // This is intentionally sequential as we are querying for results until the count of results is met.
+                    // eslint-disable-next-line no-await-in-loop
+                    const metadataSlice = await query.getExtensionMetadataAsync(index, remaining);
+                    extensions.push(...metadataSlice.map((metadata) => this._createExtension(metadata, query.feed)));
+                    remaining -= metadataSlice.length;
+                    index = 0;
+                }
+                return extensions;
+            },
+        };
+    }
+    /**
+     * Disposes the extension manager.
+     */
+    dispose() {
+        for (const installedExtension of this._installedExtensions.values()) {
+            // eslint-disable-next-line github/no-then
+            this._disableAsync(installedExtension.metadata, false).catch((error) => {
+                Logger.Warn(`Failed to disable extension ${installedExtension.metadata.name}: ${error}`);
+            });
+        }
+        this._stateChangedHandlers.clear();
+    }
+    _getInstalledExtensionStorageKey(metadata, feed) {
+        return `${this._namespace}/${GetExtensionInstalledKey(GetExtensionIdentity(feed.name, metadata.name))}`;
+    }
+    _updateInstalledExtensionsStorage() {
+        localStorage.setItem(`${this._namespace}/${InstalledExtensionsKey}`, JSON.stringify(Array.from(this._installedExtensions.values()).map((extension) => GetExtensionIdentity(extension.feed.name, extension.metadata.name))));
+    }
+    async _installAsync(metadata, feed, isNestedStateChange) {
+        let installedExtension = this._installedExtensions.get(metadata.name);
+        if (!installedExtension) {
+            installedExtension = this._createInstalledExtension(metadata, feed);
+            installedExtension.isStateChanging = true;
+            this._installedExtensions.set(metadata.name, installedExtension);
+            try {
+                // Enable the extension.
+                await this._enableAsync(metadata, true, true);
+            }
+            catch (error) {
+                this._installedExtensions.delete(metadata.name);
+                throw error;
+            }
+            finally {
+                !isNestedStateChange && (installedExtension.isStateChanging = false);
+            }
+            // Mark the extension as being installed.
+            localStorage.setItem(this._getInstalledExtensionStorageKey(metadata, feed), JSON.stringify({
+                feed: feed.name,
+                metadata,
+            }));
+            this._updateInstalledExtensionsStorage();
+        }
+        return installedExtension;
+    }
+    async _uninstallAsync(metadata, isNestedStateChange) {
+        const installedExtension = this._installedExtensions.get(metadata.name);
+        if (installedExtension && (isNestedStateChange || !installedExtension.isStateChanging)) {
+            try {
+                !isNestedStateChange && (installedExtension.isStateChanging = true);
+                // Disable the extension.
+                await this._disableAsync(metadata, true);
+                // Remove the extension from in memory.
+                this._installedExtensions.delete(metadata.name);
+                // Mark the extension as being uninstalled.
+                localStorage.removeItem(this._getInstalledExtensionStorageKey(metadata, installedExtension.feed));
+                this._updateInstalledExtensionsStorage();
+            }
+            finally {
+                !isNestedStateChange && (installedExtension.isStateChanging = false);
+            }
+        }
+    }
+    async _enableAsync(metadata, isInitialInstall, isNestedStateChange) {
+        const installedExtension = this._installedExtensions.get(metadata.name);
+        if (installedExtension && (isNestedStateChange || !installedExtension.isStateChanging)) {
+            try {
+                !isNestedStateChange && (installedExtension.isStateChanging = true);
+                // If we haven't done so already, load the extension module.
+                if (!installedExtension.extensionModule) {
+                    installedExtension.extensionModule = await installedExtension.feed.getExtensionModuleAsync(metadata.name);
+                }
+                if (!installedExtension.extensionModule) {
+                    throw new Error(`Unable to load extension module for "${metadata.name}" from feed "${installedExtension.feed.name}".`);
+                }
+                // Register the ServiceDefinitions.
+                let servicesRegistrationToken = null;
+                if (installedExtension.extensionModule.default.serviceDefinitions) {
+                    servicesRegistrationToken = await this._serviceContainer.addServicesAsync(...installedExtension.extensionModule.default.serviceDefinitions);
+                }
+                // Create a registration token to for dispose.
+                installedExtension.registrationToken = {
+                    dispose: () => {
+                        servicesRegistrationToken?.dispose();
+                    },
+                };
+            }
+            catch (error) {
+                this._onInstallFailed({
+                    extension: metadata,
+                    error,
+                });
+                throw error;
+            }
+            finally {
+                !isNestedStateChange && (installedExtension.isStateChanging = false);
+            }
+        }
+    }
+    async _disableAsync(metadata, isNestedStateChange) {
+        const installedExtension = this._installedExtensions.get(metadata.name);
+        if (installedExtension && (isNestedStateChange || !installedExtension.isStateChanging)) {
+            try {
+                !isNestedStateChange && (installedExtension.isStateChanging = true);
+                // Unregister the service registrations.
+                installedExtension.registrationToken?.dispose();
+            }
+            finally {
+                !isNestedStateChange && (installedExtension.isStateChanging = false);
+            }
+        }
+    }
+    _addStateChangedHandler(metadata, handler) {
+        let stateChangedHandlers = this._stateChangedHandlers.get(metadata.name);
+        if (!stateChangedHandlers) {
+            this._stateChangedHandlers.set(metadata.name, (stateChangedHandlers = new Set()));
+        }
+        stateChangedHandlers.add(handler);
+        return {
+            dispose: () => {
+                stateChangedHandlers.delete(handler);
+                if (stateChangedHandlers.size === 0) {
+                    this._stateChangedHandlers.delete(metadata.name);
+                }
+            },
+        };
+    }
+    _createExtension(metadata, feed) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const extensionManager = this;
+        return {
+            metadata,
+            get isStateChanging() {
+                return extensionManager._installedExtensions.get(metadata.name)?.isStateChanging ?? false;
+            },
+            get isInstalled() {
+                return extensionManager._installedExtensions.has(metadata.name);
+            },
+            installAsync: async () => {
+                await extensionManager._installAsync(metadata, feed, false);
+            },
+            uninstallAsync: async () => await extensionManager._uninstallAsync(metadata, false),
+            addStateChangedHandler: (handler) => extensionManager._addStateChangedHandler(metadata, handler),
+        };
+    }
+    _createInstalledExtension(metadata, feed) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const extensionManager = this;
+        let isStateChanging = false;
+        return {
+            metadata,
+            feed,
+            get isStateChanging() {
+                return isStateChanging;
+            },
+            set isStateChanging(value) {
+                if (value !== isStateChanging) {
+                    isStateChanging = value;
+                    extensionManager._stateChangedHandlers.get(this.metadata.name)?.forEach((handler) => handler());
+                }
+            },
+        };
+    }
+}
+//# sourceMappingURL=extensionManager.js.map