@headless-adminapp/app 1.4.42 → 1.4.44

package/README.md

@@ -21,7 +21,7 @@ Peer dependencies:
 See the project documentation and examples for end-to-end setup and usage patterns:
 
 - https://headless-adminapp.github.io/
-- https://github.com/kishanmundha/headless-adminapp-examples
+- https://headless-adminapp-examples.vercel.app/
 
 ## Development
 

package/builders/CommandBuilder.d.ts

@@ -0,0 +1,176 @@
+import { EntityFormCommandContext, EntityMainFormCommandItemExperience } from '@headless-adminapp/core/experience/form';
+import { EntityMainGridCommandItemExperience, SubGridCommandItemExperience } from '@headless-adminapp/core/experience/view';
+import { Localized } from '@headless-adminapp/core/types';
+import { Icon } from '@headless-adminapp/icons';
+export declare function localizedLabel<T extends {
+    label: string;
+    localizedLabels?: Localized<string>;
+}>(language: string, value: T, fallback?: T): string;
+export declare function createLocalizedSelector<T>(stringSet: T, localizedStringSet: Localized<T> | undefined, language: string): <U>(selector: (stringSet: T) => U) => U;
+export declare namespace CommandBuilder {
+    namespace View {
+        export function createNewRecordCommand({ Icon, text, localizedTexts, }: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        }): EntityMainGridCommandItemExperience;
+        export function createEditRecordCommand({ Icon, text, localizedTexts, }: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        }): EntityMainGridCommandItemExperience;
+        interface DeleteRecordCommandStringSet {
+            confirmation: {
+                title: string | string[];
+                text: string | string[];
+                buttonCancel: string;
+                buttonConfirm: string;
+            };
+            status: {
+                deleting: string | string[];
+            };
+            successNotification: {
+                title: string | string[];
+                text: string | string[];
+            };
+            errorNotification: {
+                title: string;
+            };
+        }
+        export const defaultDeleteRecordStringSet: DeleteRecordCommandStringSet;
+        export function createDeleteRecordCommand({ Icon, localizedText, text, stringSet, localizedStringSet, }: {
+            Icon: Icon;
+            text: string;
+            localizedText?: Record<string, string>;
+            stringSet?: DeleteRecordCommandStringSet;
+            localizedStringSet?: Localized<DeleteRecordCommandStringSet>;
+        }): EntityMainGridCommandItemExperience;
+        export function createRefreshCommand({ Icon, localizedTexts, text, }: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        }): EntityMainGridCommandItemExperience;
+        export function createExportCommand({ button, csv, excel, }: {
+            button: {
+                Icon: Icon;
+                text: string;
+                localizedTexts?: Record<string, string>;
+            };
+            excel: {
+                Icon: Icon;
+                text: string;
+                localizedTexts?: Record<string, string>;
+            };
+            csv: {
+                Icon: Icon;
+                text: string;
+                localizedTexts?: Record<string, string>;
+            };
+        }): EntityMainGridCommandItemExperience;
+        export {};
+    }
+    namespace Form {
+        export function createSaveCommand({ Icon, text, localizedTexts, }: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        }): EntityMainFormCommandItemExperience;
+        export function createSaveAndCloseCommand({ Icon, text, localizedTexts, }: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        }): EntityMainFormCommandItemExperience;
+        interface DeleteRecordCommandStringSet {
+            confirmation: {
+                title: string;
+                text: string;
+                buttonCancel: string;
+                buttonConfirm: string;
+            };
+            status: {
+                deleting: string;
+            };
+            successNotification: {
+                title: string;
+                text: string;
+            };
+            errorNotification: {
+                title: string;
+            };
+        }
+        export const defaultDeleteRecordStringSet: DeleteRecordCommandStringSet;
+        export function createDeleteCommand({ Icon, text, localizedTexts, stringSet, }: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+            stringSet: DeleteRecordCommandStringSet | ((context: EntityFormCommandContext) => DeleteRecordCommandStringSet);
+        }): EntityMainFormCommandItemExperience;
+        export function createRefreshCommand({ Icon, text, localizedTexts, }: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        }): EntityMainFormCommandItemExperience;
+        export {};
+    }
+    namespace Subgrid {
+        export function createNewRecordCommand({ Icon, text, localizedTexts, }: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        }): SubGridCommandItemExperience;
+        export function createEditRecordCommand({ Icon, text, localizedTexts, }: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        }): SubGridCommandItemExperience;
+        interface DeleteRecordCommandStringSet {
+            confirmation: {
+                title: string | string[];
+                text: string | string[];
+                buttonCancel: string;
+                buttonConfirm: string;
+            };
+            status: {
+                deleting: string | string[];
+            };
+            successNotification: {
+                title: string | string[];
+                text: string | string[];
+            };
+            errorNotification: {
+                title: string;
+            };
+        }
+        export const defaultDeleteRecordStringSet: DeleteRecordCommandStringSet;
+        export function createDeleteRecordCommand({ Icon, localizedText, text, stringSet, localizedStringSet, }: {
+            Icon: Icon;
+            text: string;
+            localizedText?: Record<string, string>;
+            stringSet?: DeleteRecordCommandStringSet;
+            localizedStringSet?: Localized<DeleteRecordCommandStringSet>;
+        }): SubGridCommandItemExperience;
+        export function createRefreshCommand({ Icon, localizedTexts, text, }: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        }): SubGridCommandItemExperience;
+        export function createExportCommand({ button, csv, excel, }: {
+            button: {
+                Icon: Icon;
+                text: string;
+                localizedTexts?: Record<string, string>;
+            };
+            excel: {
+                Icon: Icon;
+                text: string;
+                localizedTexts?: Record<string, string>;
+            };
+            csv: {
+                Icon: Icon;
+                text: string;
+                localizedTexts?: Record<string, string>;
+            };
+        }): SubGridCommandItemExperience;
+        export {};
+    }
+}

package/builders/CommandBuilder.js

@@ -0,0 +1,474 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandBuilder = void 0;
+exports.localizedLabel = localizedLabel;
+exports.createLocalizedSelector = createLocalizedSelector;
+function localizedLabel(language, value, fallback) {
+    var _a, _b, _c, _d, _e;
+    return ((_e = (_d = (_b = (_a = value.localizedLabels) === null || _a === void 0 ? void 0 : _a[language]) !== null && _b !== void 0 ? _b : (_c = fallback === null || fallback === void 0 ? void 0 : fallback.localizedLabels) === null || _c === void 0 ? void 0 : _c[language]) !== null && _d !== void 0 ? _d : value.label) !== null && _e !== void 0 ? _e : fallback === null || fallback === void 0 ? void 0 : fallback.label);
+}
+function createLocalizedSelector(stringSet, localizedStringSet, language) {
+    return function selectLocalized(selector) {
+        if (localizedStringSet && localizedStringSet[language]) {
+            return selector(localizedStringSet[language]);
+        }
+        return selector(stringSet);
+    };
+}
+var CommandBuilder;
+(function (CommandBuilder) {
+    let View;
+    (function (View) {
+        function createNewRecordCommand({ Icon, text, localizedTexts, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                onClick: (context) => {
+                    console.log('New record', context);
+                },
+                hidden: (context) => {
+                    console.log(context);
+                    // TODO: Implement logic to hide the button
+                    return false;
+                },
+            };
+        }
+        View.createNewRecordCommand = createNewRecordCommand;
+        function createEditRecordCommand({ Icon, text, localizedTexts, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                isContextMenu: true,
+                onClick: (context) => {
+                    console.log('Edit record', context);
+                },
+                hidden: (context) => context.primaryControl.selectedIds.length !== 1, // TODO: check permissions
+            };
+        }
+        View.createEditRecordCommand = createEditRecordCommand;
+        function plurialize(count, singular, plural) {
+            if (Array.isArray(singular)) {
+                plural = singular[1];
+                singular = singular[0];
+            }
+            let msg = count === 1 ? singular : plural !== null && plural !== void 0 ? plural : singular;
+            msg = msg.replace('{count}', count.toString());
+            return msg;
+        }
+        View.defaultDeleteRecordStringSet = {
+            confirmation: {
+                text: [
+                    'Are you sure you want to delete this record?',
+                    'Are you sure you want to delete selected records?',
+                ],
+                title: ['Delete record', 'Delete records'],
+                buttonConfirm: 'Delete',
+                buttonCancel: 'Cancel',
+            },
+            status: {
+                deleting: ['Deleting record', 'Deleting records'],
+            },
+            successNotification: {
+                title: ['Record deleted', 'Records deleted'],
+                text: ['Record deleted successfully', 'Records deleted successfully'],
+            },
+            errorNotification: {
+                title: 'Error',
+            },
+        };
+        function createDeleteRecordCommand({ Icon, localizedText, text, stringSet = View.defaultDeleteRecordStringSet, localizedStringSet, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText,
+                danger: true,
+                isContextMenu: true,
+                hidden: [(context) => context.primaryControl.selectedIds.length === 0], // TODO: check permissions
+                onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                    const recordIds = context.primaryControl.selectedIds;
+                    if (!recordIds.length) {
+                        return;
+                    }
+                    const localizeSelector = createLocalizedSelector(stringSet, localizedStringSet, context.locale.language);
+                    try {
+                        const confirmResult = yield context.utility.openConfirmDialog({
+                            title: plurialize(recordIds.length, localizeSelector((s) => s.confirmation.title)),
+                            text: plurialize(recordIds.length, localizeSelector((s) => s.confirmation.text)),
+                            cancelButtonLabel: localizeSelector((s) => s.confirmation.buttonCancel),
+                            confirmButtonLabel: localizeSelector((s) => s.confirmation.buttonConfirm),
+                        });
+                        if (!(confirmResult === null || confirmResult === void 0 ? void 0 : confirmResult.confirmed)) {
+                            return;
+                        }
+                        context.utility.showProgressIndicator(plurialize(recordIds.length, localizeSelector((s) => s.status.deleting)) + '...');
+                        yield new Promise((resolve) => setTimeout(resolve, 2000));
+                        context.utility.showNotification({
+                            title: plurialize(recordIds.length, localizeSelector((s) => s.successNotification.title)),
+                            text: plurialize(recordIds.length, localizeSelector((s) => s.successNotification.text)),
+                            type: 'success',
+                        });
+                        context.primaryControl.refresh();
+                    }
+                    catch (error) {
+                        context.utility.showNotification({
+                            title: localizeSelector((s) => s.errorNotification.title),
+                            text: error.message,
+                            type: 'error',
+                        });
+                    }
+                    finally {
+                        context.utility.hideProgressIndicator();
+                    }
+                }),
+            };
+        }
+        View.createDeleteRecordCommand = createDeleteRecordCommand;
+        function createRefreshCommand({ Icon, localizedTexts, text, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                onClick: (context) => {
+                    context.primaryControl.refresh();
+                },
+            };
+        }
+        View.createRefreshCommand = createRefreshCommand;
+        function createExportCommand({ button, csv, excel, }) {
+            return {
+                type: 'menu',
+                Icon: button.Icon,
+                text: button.text,
+                localizedTexts: button.localizedTexts,
+                items: [
+                    [
+                        {
+                            Icon: excel.Icon,
+                            text: excel.text,
+                            localizedTexts: excel.localizedTexts,
+                            onClick: (context) => {
+                                console.log('Export to Excel', context);
+                            },
+                        },
+                        {
+                            Icon: csv.Icon,
+                            text: csv.text,
+                            localizedTexts: csv.localizedTexts,
+                            onClick: (context) => {
+                                console.log('Export to CSV', context);
+                            },
+                        },
+                    ],
+                ],
+            };
+        }
+        View.createExportCommand = createExportCommand;
+    })(View = CommandBuilder.View || (CommandBuilder.View = {}));
+    let Form;
+    (function (Form) {
+        function createSaveCommand({ Icon, text, localizedTexts, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                isQuickAction: true,
+                onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                    yield context.primaryControl.save('save');
+                }),
+                hidden: (context) => {
+                    if (context.primaryControl.readonly) {
+                        return true;
+                    }
+                    return false;
+                },
+            };
+        }
+        Form.createSaveCommand = createSaveCommand;
+        function createSaveAndCloseCommand({ Icon, text, localizedTexts, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                    yield context.primaryControl.save('saveandclose');
+                }),
+                hidden: (context) => {
+                    if (context.primaryControl.readonly) {
+                        return true;
+                    }
+                    return false;
+                },
+            };
+        }
+        Form.createSaveAndCloseCommand = createSaveAndCloseCommand;
+        Form.defaultDeleteRecordStringSet = {
+            confirmation: {
+                text: 'Are you sure you want to delete this record?',
+                title: 'Delete record',
+                buttonConfirm: 'Delete',
+                buttonCancel: 'Cancel',
+            },
+            status: {
+                deleting: 'Deleting record',
+            },
+            successNotification: {
+                title: 'Record deleted',
+                text: 'Record deleted successfully',
+            },
+            errorNotification: {
+                title: 'Error',
+            },
+        };
+        function createDeleteCommand({ Icon, text, localizedTexts, stringSet, }) {
+            return {
+                Icon: Icon,
+                type: 'button',
+                text,
+                localizedText: localizedTexts,
+                danger: true,
+                hidden: (context) => {
+                    var _a;
+                    if (!context.primaryControl.recordId) {
+                        return true;
+                    }
+                    if ((_a = context.primaryControl.schema.restrictions) === null || _a === void 0 ? void 0 : _a.disableDelete) {
+                        return true;
+                    }
+                    return false;
+                },
+                onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                    const recordId = context.primaryControl.recordId;
+                    if (!recordId) {
+                        return;
+                    }
+                    if (typeof stringSet === 'function') {
+                        stringSet = stringSet(context);
+                    }
+                    try {
+                        const confirmResult = yield context.utility.openConfirmDialog({
+                            title: stringSet.confirmation.title,
+                            text: stringSet.confirmation.text,
+                            cancelButtonLabel: stringSet.confirmation.buttonCancel,
+                            confirmButtonLabel: stringSet.confirmation.buttonConfirm,
+                        });
+                        if (!(confirmResult === null || confirmResult === void 0 ? void 0 : confirmResult.confirmed)) {
+                            return;
+                        }
+                        context.utility.showProgressIndicator(stringSet.status.deleting + '...');
+                        yield new Promise((resolve) => setTimeout(resolve, 2000));
+                        // await context.dataService.deleteRecord(
+                        //   context.primaryControl.logicalName,
+                        //   recordId
+                        // );
+                        context.utility.showNotification({
+                            title: stringSet.successNotification.title,
+                            text: stringSet.successNotification.text,
+                            type: 'success',
+                        });
+                        // context.primaryControl.close();
+                    }
+                    catch (error) {
+                        context.utility.showNotification({
+                            title: stringSet.errorNotification.title,
+                            text: error.message,
+                            type: 'error',
+                        });
+                    }
+                    finally {
+                        context.utility.hideProgressIndicator();
+                    }
+                }),
+            };
+        }
+        Form.createDeleteCommand = createDeleteCommand;
+        function createRefreshCommand({ Icon, text, localizedTexts, }) {
+            return {
+                Icon,
+                type: 'button',
+                text,
+                localizedText: localizedTexts,
+                onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                    yield context.primaryControl.refresh();
+                }),
+                hidden: (context) => !context.primaryControl.recordId,
+            };
+        }
+        Form.createRefreshCommand = createRefreshCommand;
+    })(Form = CommandBuilder.Form || (CommandBuilder.Form = {}));
+    let Subgrid;
+    (function (Subgrid) {
+        function createNewRecordCommand({ Icon, text, localizedTexts, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                onClick: (context) => {
+                    console.log('New record', context);
+                },
+                hidden: (context) => {
+                    console.log(context);
+                    // TODO: Implement logic to hide the button
+                    return false;
+                },
+            };
+        }
+        Subgrid.createNewRecordCommand = createNewRecordCommand;
+        function createEditRecordCommand({ Icon, text, localizedTexts, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                isContextMenu: true,
+                onClick: (context) => {
+                    console.log('Edit record', context);
+                },
+                // hidden: (context) => context.secondaryControl.selectedIds.length !== 1, // TODO: check permissions
+                hidden: (context) => {
+                    console.log('temp.', context);
+                    return context.secondaryControl.selectedIds.length !== 1;
+                },
+            };
+        }
+        Subgrid.createEditRecordCommand = createEditRecordCommand;
+        function plurialize(count, singular, plural) {
+            if (Array.isArray(singular)) {
+                plural = singular[1];
+                singular = singular[0];
+            }
+            let msg = count === 1 ? singular : plural !== null && plural !== void 0 ? plural : singular;
+            msg = msg.replace('{count}', count.toString());
+            return msg;
+        }
+        Subgrid.defaultDeleteRecordStringSet = {
+            confirmation: {
+                text: [
+                    'Are you sure you want to delete this record?',
+                    'Are you sure you want to delete selected records?',
+                ],
+                title: ['Delete record', 'Delete records'],
+                buttonConfirm: 'Delete',
+                buttonCancel: 'Cancel',
+            },
+            status: {
+                deleting: ['Deleting record', 'Deleting records'],
+            },
+            successNotification: {
+                title: ['Record deleted', 'Records deleted'],
+                text: ['Record deleted successfully', 'Records deleted successfully'],
+            },
+            errorNotification: {
+                title: 'Error',
+            },
+        };
+        function createDeleteRecordCommand({ Icon, localizedText, text, stringSet = Subgrid.defaultDeleteRecordStringSet, localizedStringSet, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText,
+                danger: true,
+                isContextMenu: true,
+                hidden: [
+                    (context) => context.secondaryControl.selectedIds.length === 0,
+                ], // TODO: check permissions
+                onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                    const recordIds = context.secondaryControl.selectedIds;
+                    if (!recordIds.length) {
+                        return;
+                    }
+                    const localizeSelector = createLocalizedSelector(stringSet, localizedStringSet, context.locale.language);
+                    try {
+                        const confirmResult = yield context.utility.openConfirmDialog({
+                            title: plurialize(recordIds.length, localizeSelector((s) => s.confirmation.title)),
+                            text: plurialize(recordIds.length, localizeSelector((s) => s.confirmation.text)),
+                            cancelButtonLabel: localizeSelector((s) => s.confirmation.buttonCancel),
+                            confirmButtonLabel: localizeSelector((s) => s.confirmation.buttonConfirm),
+                        });
+                        if (!(confirmResult === null || confirmResult === void 0 ? void 0 : confirmResult.confirmed)) {
+                            return;
+                        }
+                        context.utility.showProgressIndicator(plurialize(recordIds.length, localizeSelector((s) => s.status.deleting)) + '...');
+                        yield new Promise((resolve) => setTimeout(resolve, 2000));
+                        context.utility.showNotification({
+                            title: plurialize(recordIds.length, localizeSelector((s) => s.successNotification.title)),
+                            text: plurialize(recordIds.length, localizeSelector((s) => s.successNotification.text)),
+                            type: 'success',
+                        });
+                        yield context.primaryControl.refresh();
+                    }
+                    catch (error) {
+                        context.utility.showNotification({
+                            title: localizeSelector((s) => s.errorNotification.title),
+                            text: error.message,
+                            type: 'error',
+                        });
+                    }
+                    finally {
+                        context.utility.hideProgressIndicator();
+                    }
+                }),
+            };
+        }
+        Subgrid.createDeleteRecordCommand = createDeleteRecordCommand;
+        function createRefreshCommand({ Icon, localizedTexts, text, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                onClick: (context) => {
+                    context.secondaryControl.refresh();
+                },
+            };
+        }
+        Subgrid.createRefreshCommand = createRefreshCommand;
+        function createExportCommand({ button, csv, excel, }) {
+            return {
+                type: 'menu',
+                Icon: button.Icon,
+                text: button.text,
+                localizedTexts: button.localizedTexts,
+                items: [
+                    [
+                        {
+                            Icon: excel.Icon,
+                            text: excel.text,
+                            localizedTexts: excel.localizedTexts,
+                            onClick: (context) => {
+                                console.log('Export to Excel', context);
+                            },
+                        },
+                        {
+                            Icon: csv.Icon,
+                            text: csv.text,
+                            localizedTexts: csv.localizedTexts,
+                            onClick: (context) => {
+                                console.log('Export to CSV', context);
+                            },
+                        },
+                    ],
+                ],
+            };
+        }
+        Subgrid.createExportCommand = createExportCommand;
+    })(Subgrid = CommandBuilder.Subgrid || (CommandBuilder.Subgrid = {}));
+})(CommandBuilder || (exports.CommandBuilder = CommandBuilder = {}));

package/metadata/hooks/useAppStore.d.ts

@@ -0,0 +1 @@
+export declare function useAppStore(): import("@headless-adminapp/core/store").IClientAppStore;

package/metadata/hooks/useAppStore.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAppStore = useAppStore;
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+function useAppStore() {
+    return (0, context_1.useContextSelector)(context_2.MetadataContext, (state) => state.appStore);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@headless-adminapp/app",
-  "version": "1.4.42",
+  "version": "1.4.44",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -38,5 +38,5 @@
     "uuid": "11.0.3",
     "yup": "^1.4.0"
   },
-  "gitHead": "ab95b45e2c1098d0524b19ba32cce202be8e7439"
+  "gitHead": "b61cc3933fdf461afd3e59859ea1a89469d4523a"
 }

package/store/ClientAppStore.d.ts

@@ -0,0 +1,7 @@
+import { AppExperience } from '@headless-adminapp/core/experience/app';
+import { IClientAppStore } from '@headless-adminapp/core/store';
+export declare class ClientAppStore implements IClientAppStore {
+    private apps;
+    register(app: AppExperience): void;
+    getApp(id: string): Promise<AppExperience>;
+}

package/store/ClientAppStore.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientAppStore = void 0;
+class ClientAppStore {
+    constructor() {
+        this.apps = {};
+    }
+    register(app) {
+        this.apps[app.id] = app;
+    }
+    getApp(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const app = this.apps[id];
+            if (!app) {
+                throw new Error(`App Experience for ${id} not found`);
+            }
+            return app;
+        });
+    }
+}
+exports.ClientAppStore = ClientAppStore;

package/widget/context.d.ts

@@ -0,0 +1,2 @@
+import { WidgetState } from '@headless-adminapp/core/experience/insights';
+export declare const WidgetContext: import("react").Context<import("../mutable").ContextValue<WidgetState<import("@headless-adminapp/core/schema").SchemaAttributes>>>;

package/widget/context.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetContext = void 0;
+const mutable_1 = require("../mutable");
+exports.WidgetContext = (0, mutable_1.createContext)();

package/widget/hooks/index.d.ts

@@ -0,0 +1,3 @@
+import { WidgetState } from '@headless-adminapp/core/experience/insights';
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+export declare function useWidgetState<S extends SchemaAttributes = SchemaAttributes>(): WidgetState<S>;

package/widget/hooks/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWidgetState = useWidgetState;
+const mutable_1 = require("../../mutable");
+const context_1 = require("../context");
+function useWidgetState() {
+    return (0, mutable_1.useContextSelector)(context_1.WidgetContext, (state) => state);
+}

package/widget/index.d.ts

@@ -0,0 +1 @@
+export { WidgetContext } from './context';

package/widget/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetContext = void 0;
+var context_1 = require("./context");
+Object.defineProperty(exports, "WidgetContext", { enumerable: true, get: function () { return context_1.WidgetContext; } });