@headless-adminapp/app 0.0.8-0.0.9-alpha.1.0

package/dist/locale/context.d.ts

@@ -0,0 +1,2 @@
+import { Dispatch, SetStateAction } from 'react';
+export declare const LocaleContext: import("react").Context<[import("@headless-adminapp/core/experience/app").Locale, Dispatch<SetStateAction<import("@headless-adminapp/core/experience/app").Locale>>] | null>;

package/dist/locale/context.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocaleContext = void 0;
+const react_1 = require("react");
+exports.LocaleContext = (0, react_1.createContext)(null);

package/dist/locale/index.d.ts

@@ -0,0 +1,3 @@
+export { LocaleContext } from './context';
+export * from './types';
+export * from './useLocale';

package/dist/locale/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 });
+exports.LocaleContext = void 0;
+var context_1 = require("./context");
+Object.defineProperty(exports, "LocaleContext", { enumerable: true, get: function () { return context_1.LocaleContext; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./useLocale"), exports);

package/dist/locale/types.d.ts

@@ -0,0 +1,2 @@
+import { Locale } from '@headless-adminapp/core/experience/app';
+export type LocaleContextState = Locale;

package/dist/locale/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/locale/useLocale.d.ts

@@ -0,0 +1 @@
+export declare function useLocale(): [import("@headless-adminapp/core/experience/app").Locale, import("react").Dispatch<import("react").SetStateAction<import("@headless-adminapp/core/experience/app").Locale>>];

package/dist/locale/useLocale.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLocale = useLocale;
+const react_1 = require("react");
+const context_1 = require("./context");
+function useLocale() {
+    const context = (0, react_1.useContext)(context_1.LocaleContext);
+    if (!context) {
+        throw new Error('useLocale must be used within a LocaleProvider');
+    }
+    return context;
+}

package/dist/metadata/MetadataProvider.d.ts

@@ -0,0 +1,9 @@
+import { IClientAppStore, ISchemaExperienceStore, ISchemaStore } from '@headless-adminapp/core/store';
+import { FC, PropsWithChildren } from 'react';
+interface MetadataProviderProps {
+    schemaStore: ISchemaStore;
+    experienceStore: ISchemaExperienceStore;
+    appStore: IClientAppStore;
+}
+export declare const MetadataProvider: FC<PropsWithChildren<MetadataProviderProps>>;
+export {};

package/dist/metadata/MetadataProvider.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataProvider = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const context_1 = require("../mutable/context");
+const context_2 = require("./context");
+const MetadataProvider = ({ children, experienceStore, schemaStore, appStore, }) => {
+    const contextValue = (0, context_1.useCreateContextStore)({
+        // schemas: {},
+        // schemaLoading: true,
+        experienceStore,
+        schemaStore,
+        appStore,
+    });
+    // const [loading, setLoading] = useState(true);
+    // useEffect(() => {
+    //   const schemas = schemaStore.getSchemas();
+    //   contextValue.setValue({
+    //     schemas,
+    //     schemaLoading: false,
+    //   });
+    //   setLoading(false);
+    // }, [contextValue, schemaStore]);
+    // if (loading) {
+    //   return null;
+    // }
+    return ((0, jsx_runtime_1.jsx)(context_2.MetadataContext.Provider, { value: contextValue, children: children }));
+};
+exports.MetadataProvider = MetadataProvider;

package/dist/metadata/context.d.ts

@@ -0,0 +1,7 @@
+import { IClientAppStore, ISchemaExperienceStore, ISchemaStore } from '@headless-adminapp/core/store';
+export interface MetadataContextState {
+    appStore: IClientAppStore;
+    schemaStore: ISchemaStore;
+    experienceStore: ISchemaExperienceStore;
+}
+export declare const MetadataContext: import("react").Context<import("../mutable/context").ContextValue<MetadataContextState>>;

package/dist/metadata/context.js

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

package/dist/metadata/hooks/index.d.ts

@@ -0,0 +1,8 @@
+export * from './useAppStore';
+export * from './useExperienceStore';
+export * from './useExperienceView';
+export * from './useExperienceViewCommands';
+export * from './useExperienceViewLookup';
+export * from './useExperienceViewSubgridCommands';
+export * from './useMetadata';
+export * from './useSchema';

package/dist/metadata/hooks/index.js

@@ -0,0 +1,24 @@
+"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("./useAppStore"), exports);
+__exportStar(require("./useExperienceStore"), exports);
+__exportStar(require("./useExperienceView"), exports);
+__exportStar(require("./useExperienceViewCommands"), exports);
+__exportStar(require("./useExperienceViewLookup"), exports);
+__exportStar(require("./useExperienceViewSubgridCommands"), exports);
+__exportStar(require("./useMetadata"), exports);
+__exportStar(require("./useSchema"), exports);

package/dist/metadata/hooks/useAppStore.d.ts

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

package/dist/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/dist/metadata/hooks/useExperienceStore.d.ts

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

package/dist/metadata/hooks/useExperienceStore.js

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

package/dist/metadata/hooks/useExperienceView.d.ts

@@ -0,0 +1,4 @@
+export declare function useExperienceView(logicalName: string, viewId?: string, associated?: boolean, viewIds?: string[]): {
+    view: import("@headless-adminapp/core/experience/view").View<import("@headless-adminapp/core/schema").SchemaAttributes> | undefined;
+    isLoadingView: boolean;
+};

package/dist/metadata/hooks/useExperienceView.js

@@ -0,0 +1,37 @@
+"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.useExperienceView = useExperienceView;
+const react_query_1 = require("@tanstack/react-query");
+const useExperienceStore_1 = require("./useExperienceStore");
+function useExperienceView(logicalName, viewId, associated, viewIds) {
+    const experienceStore = (0, useExperienceStore_1.useExperienceStore)();
+    const { data, isPending } = (0, react_query_1.useQuery)({
+        queryKey: [
+            'experience-schema-view',
+            logicalName,
+            viewId,
+            associated,
+            viewIds,
+        ],
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            if (associated) {
+                return experienceStore.getAssociatedView(logicalName, viewId, viewIds);
+            }
+            return experienceStore.getPublicView(logicalName, viewId, viewIds);
+        }),
+        placeholderData: react_query_1.keepPreviousData,
+    });
+    return {
+        view: data,
+        isLoadingView: isPending,
+    };
+}

package/dist/metadata/hooks/useExperienceViewCommands.d.ts

@@ -0,0 +1,4 @@
+/** @todo move in different dir */
+export declare function useExperienceViewCommands(logicalName: string): {
+    commands: import("@headless-adminapp/core/experience/view").EntityMainGridCommandItemExperience[][];
+};

package/dist/metadata/hooks/useExperienceViewCommands.js

@@ -0,0 +1,28 @@
+"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.useExperienceViewCommands = useExperienceViewCommands;
+const react_query_1 = require("@tanstack/react-query");
+const useExperienceStore_1 = require("./useExperienceStore");
+/** @todo move in different dir */
+function useExperienceViewCommands(logicalName) {
+    const experienceStore = (0, useExperienceStore_1.useExperienceStore)();
+    const { data: commands } = (0, react_query_1.useQuery)({
+        queryKey: ['experience-schema-view-commands', logicalName],
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            return experienceStore.getViewCommands(logicalName);
+        }),
+        initialData: [],
+    });
+    return {
+        commands,
+    };
+}

package/dist/metadata/hooks/useExperienceViewLookup.d.ts

@@ -0,0 +1,4 @@
+/** @todo move in different dir */
+export declare function useExperienceViewLookup(logicalName: string, associated?: boolean, viewIds?: string[]): {
+    viewLookup: import("@headless-adminapp/core/attributes").LocalizedDataLookup[];
+};

package/dist/metadata/hooks/useExperienceViewLookup.js

@@ -0,0 +1,36 @@
+"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.useExperienceViewLookup = useExperienceViewLookup;
+const react_query_1 = require("@tanstack/react-query");
+const useExperienceStore_1 = require("./useExperienceStore");
+/** @todo move in different dir */
+function useExperienceViewLookup(logicalName, associated, viewIds) {
+    const experienceStore = (0, useExperienceStore_1.useExperienceStore)();
+    const { data: viewLookup } = (0, react_query_1.useQuery)({
+        queryKey: [
+            'experience-schema-view-lookup',
+            logicalName,
+            associated,
+            viewIds,
+        ],
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            if (associated) {
+                return experienceStore.getAssociatedViewLookup(logicalName, viewIds);
+            }
+            return experienceStore.getPublicViewLookup(logicalName, viewIds);
+        }),
+        initialData: [],
+    });
+    return {
+        viewLookup,
+    };
+}

package/dist/metadata/hooks/useExperienceViewSubgridCommands.d.ts

@@ -0,0 +1,4 @@
+/** @todo move in different dir */
+export declare function useExperienceViewSubgridCommands(logicalName: string): {
+    commands: import("@headless-adminapp/core/experience/view").SubGridCommandItemExperience[][];
+};

package/dist/metadata/hooks/useExperienceViewSubgridCommands.js

@@ -0,0 +1,28 @@
+"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.useExperienceViewSubgridCommands = useExperienceViewSubgridCommands;
+const react_query_1 = require("@tanstack/react-query");
+const useExperienceStore_1 = require("./useExperienceStore");
+/** @todo move in different dir */
+function useExperienceViewSubgridCommands(logicalName) {
+    const experienceStore = (0, useExperienceStore_1.useExperienceStore)();
+    const { data: commands } = (0, react_query_1.useQuery)({
+        queryKey: ['experience-schema-view-subgrid-commands', logicalName],
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            return experienceStore.getSubgridCommands(logicalName);
+        }),
+        initialData: [],
+    });
+    return {
+        commands,
+    };
+}

package/dist/metadata/hooks/useMetadata.d.ts

@@ -0,0 +1,9 @@
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+export declare function useMetadata(): {
+    schemas: Record<string, import("@headless-adminapp/core/schema").Schema<SchemaAttributes>>;
+    schemaLoading: boolean;
+    getSchema: <S extends SchemaAttributes = SchemaAttributes>(logicalName: string) => import("@headless-adminapp/core/schema").Schema<S>;
+    schemaStore: import("@headless-adminapp/core/store").ISchemaStore<SchemaAttributes>;
+    appStore: import("@headless-adminapp/core/store").IClientAppStore;
+    experienceStore: import("@headless-adminapp/core/store").ISchemaExperienceStore;
+};

package/dist/metadata/hooks/useMetadata.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMetadata = useMetadata;
+const react_1 = require("react");
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+function useMetadata() {
+    const schemaStore = (0, context_1.useContextSelector)(context_2.MetadataContext, (state) => state.schemaStore);
+    const appStore = (0, context_1.useContextSelector)(context_2.MetadataContext, (state) => state.appStore);
+    const experienceStore = (0, context_1.useContextSelector)(context_2.MetadataContext, (state) => state.experienceStore);
+    // const schemaLoading = useContextSelector(
+    //   MetadataContext,
+    //   (state) => state.schemaLoading
+    // );
+    const schemaLoading = false;
+    const schemas = schemaStore.getAllSchema();
+    const getSchema = (0, react_1.useCallback)((logicalName) => {
+        return schemaStore.getSchema(logicalName);
+    }, [schemaStore]);
+    return {
+        schemas,
+        schemaLoading,
+        getSchema,
+        schemaStore,
+        appStore,
+        experienceStore,
+    };
+}

package/dist/metadata/hooks/useSchema.d.ts

@@ -0,0 +1,2 @@
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+export declare function useSchema<S extends SchemaAttributes = SchemaAttributes>(logicalName: string): import("@headless-adminapp/core/schema").Schema<S>;

package/dist/metadata/hooks/useSchema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSchema = useSchema;
+const useMetadata_1 = require("./useMetadata");
+function useSchema(logicalName) {
+    const { getSchema } = (0, useMetadata_1.useMetadata)();
+    return getSchema(logicalName);
+}

package/dist/metadata/index.d.ts

@@ -0,0 +1,3 @@
+export { MetadataProvider } from './MetadataProvider';
+export { MetadataContext, type MetadataContextState } from './context';
+export * from './hooks';

package/dist/metadata/index.js

@@ -0,0 +1,22 @@
+"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 });
+exports.MetadataContext = exports.MetadataProvider = void 0;
+var MetadataProvider_1 = require("./MetadataProvider");
+Object.defineProperty(exports, "MetadataProvider", { enumerable: true, get: function () { return MetadataProvider_1.MetadataProvider; } });
+var context_1 = require("./context");
+Object.defineProperty(exports, "MetadataContext", { enumerable: true, get: function () { return context_1.MetadataContext; } });
+__exportStar(require("./hooks"), exports);

package/dist/mutable/context.d.ts

@@ -0,0 +1,11 @@
+import { MutableValue } from './type';
+import { useMutableValueSelector } from './utils';
+export type ContextValue<T> = MutableValue<T>;
+export declare const useContextSelectorInternal: typeof useMutableValueSelector;
+export declare function createContext<T>(): import("react").Context<ContextValue<T>>;
+export declare function useCreateContextStore<T>(initialValue: T): MutableValue<T>;
+export declare function useContextSelector<T, R>(context: React.Context<ContextValue<T>>, selector: (state: T) => R): R;
+export declare function useContextSetValue<T>(context: React.Context<ContextValue<T>>): (value: Partial<T> | ((state: T) => Partial<T>)) => void;
+type Setter<T, U extends unknown[]> = (setValue: ContextValue<T>['setValue']) => (...args: U) => void;
+export declare function useContextValueSetter<T, U extends unknown[]>(context: React.Context<ContextValue<T>>, setter: Setter<T, U>): (...args: U) => void;
+export {};

package/dist/mutable/context.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useContextSelectorInternal = void 0;
+exports.createContext = createContext;
+exports.useCreateContextStore = useCreateContextStore;
+exports.useContextSelector = useContextSelector;
+exports.useContextSetValue = useContextSetValue;
+exports.useContextValueSetter = useContextValueSetter;
+const react_1 = require("react");
+const utils_1 = require("./utils");
+const createContextValue = utils_1.createMutableValue;
+exports.useContextSelectorInternal = utils_1.useMutableValueSelector;
+function createContext() {
+    const context = (0, react_1.createContext)(null);
+    return context;
+}
+function useCreateContextStore(initialValue) {
+    const [state] = (0, react_1.useState)(() => createContextValue(initialValue));
+    return state;
+}
+function useContextSelector(context, selector) {
+    const contextValue = (0, react_1.useContext)(context);
+    if (!contextValue) {
+        throw new Error('useContextSelector must be used within a Provider');
+    }
+    return (0, exports.useContextSelectorInternal)(contextValue, selector);
+}
+function useContextSetValue(context) {
+    const contextValue = (0, react_1.useContext)(context);
+    if (!contextValue) {
+        throw new Error('useContextSetValue must be used within a Provider');
+    }
+    return contextValue.setValue;
+}
+function useContextValueSetter(context, setter) {
+    const contextValue = (0, react_1.useContext)(context);
+    if (!contextValue) {
+        throw new Error('useContextValueSetter must be used within a Provider');
+    }
+    const setterRef = (0, react_1.useRef)(setter);
+    setterRef.current = setter;
+    const setterWrapper = (0, react_1.useCallback)((...args) => {
+        return setterRef.current(contextValue.setValue)(...args);
+    }, []);
+    return setterWrapper;
+}

package/dist/mutable/index.d.ts

@@ -0,0 +1,3 @@
+export { createContext, useContextSelector, useContextSetValue, useCreateContextStore, type ContextValue, } from './context';
+export { useMutableState, useMutableStateSelector } from './state';
+export * from './type';

package/dist/mutable/index.js

@@ -0,0 +1,26 @@
+"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 });
+exports.useMutableStateSelector = exports.useMutableState = exports.useCreateContextStore = exports.useContextSetValue = exports.useContextSelector = exports.createContext = void 0;
+var context_1 = require("./context");
+Object.defineProperty(exports, "createContext", { enumerable: true, get: function () { return context_1.createContext; } });
+Object.defineProperty(exports, "useContextSelector", { enumerable: true, get: function () { return context_1.useContextSelector; } });
+Object.defineProperty(exports, "useContextSetValue", { enumerable: true, get: function () { return context_1.useContextSetValue; } });
+Object.defineProperty(exports, "useCreateContextStore", { enumerable: true, get: function () { return context_1.useCreateContextStore; } });
+var state_1 = require("./state");
+Object.defineProperty(exports, "useMutableState", { enumerable: true, get: function () { return state_1.useMutableState; } });
+Object.defineProperty(exports, "useMutableStateSelector", { enumerable: true, get: function () { return state_1.useMutableStateSelector; } });
+__exportStar(require("./type"), exports);

package/dist/mutable/state.d.ts

@@ -0,0 +1,6 @@
+import { MutableValue } from './type';
+import { createMutableValue, useMutableValueSelector } from './utils';
+export type MutableState<T> = MutableValue<T>;
+export declare const createMutableState: typeof createMutableValue;
+export declare const useMutableStateSelector: typeof useMutableValueSelector;
+export declare function useMutableState<T>(initialValue: T, isArray?: boolean): MutableValue<T>;

package/dist/mutable/state.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMutableStateSelector = exports.createMutableState = void 0;
+exports.useMutableState = useMutableState;
+const react_1 = require("react");
+const utils_1 = require("./utils");
+exports.createMutableState = utils_1.createMutableValue;
+exports.useMutableStateSelector = utils_1.useMutableValueSelector;
+function useMutableState(initialValue, isArray) {
+    const [state] = (0, react_1.useState)(() => (0, exports.createMutableState)(initialValue, isArray));
+    return state;
+}

package/dist/mutable/type.d.ts

@@ -0,0 +1,11 @@
+type Listener<T> = (state: T) => void;
+export interface MutableValue<T> {
+    value: {
+        current: T;
+    };
+    setValue: (value: Partial<T> | ((state: T) => Partial<T>)) => void;
+    listeners: Set<Listener<T>>;
+    addListener: (listener: Listener<T>) => void;
+    removeListener: (listener: Listener<T>) => void;
+}
+export {};

package/dist/mutable/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/mutable/utils.d.ts

@@ -0,0 +1,3 @@
+import { MutableValue } from './type';
+export declare function createMutableValue<T>(initialValue: T, isArray?: boolean): MutableValue<T>;
+export declare function useMutableValueSelector<T, R>(mutableValue: MutableValue<T>, selector: (state: T) => R): R;

package/dist/mutable/utils.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMutableValue = createMutableValue;
+exports.useMutableValueSelector = useMutableValueSelector;
+const react_1 = require("react");
+function createMutableValue(initialValue, isArray) {
+    let storeValue = {
+        current: initialValue,
+    };
+    const listeners = new Set();
+    return {
+        value: storeValue,
+        setValue: (value) => {
+            if (typeof value === 'function') {
+                if (isArray) {
+                    storeValue.current = value(storeValue.current);
+                }
+                else {
+                    storeValue.current = Object.assign(Object.assign({}, storeValue.current), value(storeValue.current));
+                }
+            }
+            else {
+                if (isArray) {
+                    storeValue.current = value;
+                }
+                else {
+                    storeValue.current = Object.assign(Object.assign({}, storeValue.current), value);
+                }
+            }
+            listeners.forEach((listener) => listener(storeValue.current));
+        },
+        listeners,
+        addListener: (listener) => listeners.add(listener),
+        removeListener: (listener) => listeners.delete(listener),
+    };
+}
+function useMutableValueSelector(mutableValue, selector) {
+    const selectorRef = (0, react_1.useRef)(selector);
+    selectorRef.current = selector;
+    const [value, setValue] = (0, react_1.useState)({
+        innerValue: selectorRef.current(mutableValue.value.current),
+    });
+    const valueRef = (0, react_1.useRef)(value);
+    valueRef.current = value;
+    (0, react_1.useEffect)(() => {
+        const listener = (state) => {
+            const newValue = selectorRef.current(state);
+            if (newValue !== valueRef.current.innerValue) {
+                setValue({
+                    innerValue: newValue,
+                });
+            }
+        };
+        mutableValue.addListener(listener);
+        // Trigger value which update while adding listener
+        listener(mutableValue.value.current);
+        return () => {
+            mutableValue.removeListener(listener);
+        };
+    }, [mutableValue]);
+    return value.innerValue;
+}

package/dist/navigation/hooks/useOpenForm.d.ts

@@ -0,0 +1,4 @@
+import { PageEntiyForm } from '@headless-adminapp/core/experience/app';
+export declare function useOpenForm(): (formOptions: Omit<PageEntiyForm, "type">, navigationOptions: {
+    replace?: boolean;
+}) => void;