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

package/dist/datagrid/hooks/useSubGridCommands.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSubGridCommandHandlerContext = useSubGridCommandHandlerContext;
+exports.useSubGridCommands = useSubGridCommands;
+exports.useSubGridContextCommands = useSubGridContextCommands;
+const react_query_1 = require("@tanstack/react-query");
+const react_1 = require("react");
+const command_1 = require("../../command");
+const useMainFormCommands_1 = require("../../dataform/hooks/useMainFormCommands");
+const useLocale_1 = require("../../locale/useLocale");
+const useMetadata_1 = require("../../metadata/hooks/useMetadata");
+const transport_1 = require("../../transport");
+const useGridColumnFilter_1 = require("./useGridColumnFilter");
+const useGridCommands_1 = require("./useGridCommands");
+const useGridData_1 = require("./useGridData");
+const useGridExtraFilter_1 = require("./useGridExtraFilter");
+const useGridRefresh_1 = require("./useGridRefresh");
+const useGridSchema_1 = require("./useGridSchema");
+const useGridSelection_1 = require("./useGridSelection");
+const useMainGridCommands_1 = require("./useMainGridCommands");
+const useSearchText_1 = require("./useSearchText");
+const useSelectedView_1 = require("./useSelectedView");
+function useSubGridCommandHandlerContext() {
+    const dataService = (0, transport_1.useDataService)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    const { appStore, experienceStore, schemaStore } = (0, useMetadata_1.useMetadata)();
+    const data = (0, useGridData_1.useGridData)();
+    const schema = (0, useGridSchema_1.useDataGridSchema)();
+    const view = (0, useSelectedView_1.useSelectedView)();
+    const [searchText] = (0, useSearchText_1.useSearchText)();
+    const [selectedIds] = (0, useGridSelection_1.useGridSelection)();
+    const selectedIdsObj = (0, react_1.useMemo)(() => {
+        const obj = {};
+        selectedIds.forEach((id) => {
+            obj[id] = true;
+        });
+        return obj;
+    }, [selectedIds]);
+    const selectedRecords = (0, react_1.useMemo)(() => {
+        var _a;
+        return ((_a = data === null || data === void 0 ? void 0 : data.records) !== null && _a !== void 0 ? _a : []).filter((record) => selectedIdsObj[record[schema.idAttribute]]);
+    }, [data, schema, selectedIdsObj]);
+    const [columnFilter] = (0, useGridColumnFilter_1.useGridColumnFilter)();
+    const extraFilter = (0, useGridExtraFilter_1.useGridExtraFilter)();
+    const refresh = (0, useGridRefresh_1.useGridRefresh)();
+    const utility = (0, useMainGridCommands_1.useUtility)();
+    const [locale] = (0, useLocale_1.useLocale)();
+    const mainFormHandlerContext = (0, useMainFormCommands_1.useMainFormCommandHandlerContext)();
+    // console.log('mainFormHandlerContext', mainFormHandlerContext);
+    return {
+        dataService,
+        queryClient,
+        utility,
+        primaryControl: mainFormHandlerContext.primaryControl,
+        secondaryControl: {
+            data,
+            logicalName: schema.logicalName,
+            schema,
+            refresh,
+            searchText,
+            selectedIds,
+            selectedRecords,
+            view,
+            viewId: view.id,
+            columnFilter,
+            extraFilter,
+        },
+        stores: {
+            appStore,
+            experienceStore,
+            schemaStore,
+        },
+        locale,
+    };
+}
+function useSubGridCommands() {
+    const commands = (0, useGridCommands_1.useGridCommands)();
+    const handlerContext = useSubGridCommandHandlerContext();
+    console.log('temp. commands (s)', commands);
+    console.log('temp. handlerContext (s)', handlerContext);
+    return (0, command_1.useCommands)(commands, handlerContext);
+}
+function useSubGridContextCommands() {
+    const commands = (0, useGridCommands_1.useGridCommands)();
+    const handlerContext = useSubGridCommandHandlerContext();
+    return (0, command_1.useCommands)(commands, handlerContext, (command) => { var _a; return (_a = ('isContextMenu' in command && command.isContextMenu)) !== null && _a !== void 0 ? _a : false; });
+}

package/dist/dialog/DialogProvider.d.ts

@@ -0,0 +1,5 @@
+import { FC, PropsWithChildren } from 'react';
+interface DialogProviderProps {
+}
+export declare const DialogProvider: FC<PropsWithChildren<DialogProviderProps>>;
+export {};

package/dist/dialog/DialogProvider.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogProvider = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const context_1 = require("../mutable/context");
+const context_2 = require("./context");
+const DialogProvider = ({ children, }) => {
+    const contextState = (0, context_1.useCreateContextStore)({
+        items: [],
+    });
+    return ((0, jsx_runtime_1.jsx)(context_2.DialogContext.Provider, { value: contextState, children: children }));
+};
+exports.DialogProvider = DialogProvider;

package/dist/dialog/context.d.ts

@@ -0,0 +1,6 @@
+import { BasicDialogProps, DialogOptions } from '@headless-adminapp/core/experience/dialog';
+export type DialogItemState = BasicDialogProps & DialogOptions;
+export interface DialogContextState {
+    items: DialogItemState[];
+}
+export declare const DialogContext: import("react").Context<import("../mutable/context").ContextValue<DialogContextState>>;

package/dist/dialog/context.js

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

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

@@ -0,0 +1,8 @@
+export * from './useCloseDialog';
+export * from './useDialogItem';
+export * from './useDialogItems';
+export * from './useOpenAlertDialog';
+export * from './useOpenConfirmDialog';
+export * from './useOpenDialog';
+export * from './useOpenErrorDialog';
+export * from './useOpenPromptDialog';

package/dist/dialog/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("./useCloseDialog"), exports);
+__exportStar(require("./useDialogItem"), exports);
+__exportStar(require("./useDialogItems"), exports);
+__exportStar(require("./useOpenAlertDialog"), exports);
+__exportStar(require("./useOpenConfirmDialog"), exports);
+__exportStar(require("./useOpenDialog"), exports);
+__exportStar(require("./useOpenErrorDialog"), exports);
+__exportStar(require("./useOpenPromptDialog"), exports);

package/dist/dialog/hooks/useCloseDialog.d.ts

@@ -0,0 +1 @@
+export declare function useCloseDialog(): (id: string) => void;

package/dist/dialog/hooks/useCloseDialog.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCloseDialog = useCloseDialog;
+const react_1 = require("react");
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+function useCloseDialog() {
+    const setValue = (0, context_1.useContextSetValue)(context_2.DialogContext);
+    const closeDialog = (0, react_1.useCallback)((id) => {
+        setValue((state) => {
+            return {
+                items: state.items.map((item) => {
+                    if (item.id === id) {
+                        return Object.assign(Object.assign({}, item), { isOpen: false });
+                    }
+                    return item;
+                }),
+            };
+        });
+        // Simulate a delay to show the dialog closing animation
+        setTimeout(() => {
+            setValue((state) => {
+                return {
+                    items: state.items.filter((item) => item.id !== id),
+                };
+            });
+        }, 1000);
+    }, [setValue]);
+    return closeDialog;
+}

package/dist/dialog/hooks/useDialogItem.d.ts

@@ -0,0 +1 @@
+export declare function useDialogItem(id: string): import("../context").DialogItemState | undefined;

package/dist/dialog/hooks/useDialogItem.js

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

package/dist/dialog/hooks/useDialogItems.d.ts

@@ -0,0 +1 @@
+export declare function useDialogItems(): import("../context").DialogItemState[];

package/dist/dialog/hooks/useDialogItems.js

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

package/dist/dialog/hooks/useOpenAlertDialog.d.ts

@@ -0,0 +1,2 @@
+import { AlertDialogOptions } from '@headless-adminapp/core/experience/dialog';
+export declare function useOpenAlertDialog(): (options: Omit<AlertDialogOptions, "type" | "onConfirm" | "onClose">) => Promise<void>;

package/dist/dialog/hooks/useOpenAlertDialog.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOpenAlertDialog = useOpenAlertDialog;
+const react_1 = require("react");
+const useOpenDialog_1 = require("./useOpenDialog");
+function useOpenAlertDialog() {
+    const openDialog = (0, useOpenDialog_1.useOpenDialog)();
+    const openAlertDialog = (0, react_1.useCallback)((options) => {
+        return new Promise((resolve) => {
+            const { close } = openDialog(Object.assign(Object.assign({ type: 'alert' }, options), { onDismiss: () => {
+                    close();
+                    resolve();
+                }, onConfirm: () => {
+                    close();
+                    resolve();
+                } }));
+        });
+    }, [openDialog]);
+    return openAlertDialog;
+}

package/dist/dialog/hooks/useOpenConfirmDialog.d.ts

@@ -0,0 +1,2 @@
+import { ConfirmDialogOptions, ConfirmResult } from '@headless-adminapp/core/experience/dialog';
+export declare function useOpenConfirmDialog(): (options: Omit<ConfirmDialogOptions, "type" | "onConfirm" | "onDismiss" | "onCancel">) => Promise<ConfirmResult | null>;

package/dist/dialog/hooks/useOpenConfirmDialog.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOpenConfirmDialog = useOpenConfirmDialog;
+const react_1 = require("react");
+const useOpenDialog_1 = require("./useOpenDialog");
+function useOpenConfirmDialog() {
+    const openDialog = (0, useOpenDialog_1.useOpenDialog)();
+    const openConfirmDialog = (0, react_1.useCallback)((options) => {
+        return new Promise((resolve) => {
+            const { close } = openDialog(Object.assign(Object.assign({ type: 'confirm' }, options), { onDismiss: () => {
+                    if (!options.allowDismiss) {
+                        return;
+                    }
+                    close();
+                    resolve(null);
+                }, onConfirm: () => {
+                    close();
+                    resolve({ confirmed: true });
+                }, onCancel: () => {
+                    close();
+                    resolve({ confirmed: false });
+                } }));
+        });
+    }, [openDialog]);
+    return openConfirmDialog;
+}

package/dist/dialog/hooks/useOpenDialog.d.ts

@@ -0,0 +1,5 @@
+import { DialogOptions } from '@headless-adminapp/core/experience/dialog';
+export declare function useOpenDialog(): (options: DialogOptions) => {
+    id: string;
+    close: () => void;
+};

package/dist/dialog/hooks/useOpenDialog.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOpenDialog = useOpenDialog;
+const react_1 = require("react");
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+const useCloseDialog_1 = require("./useCloseDialog");
+function randomId() {
+    return Math.random().toString(36).substring(2);
+}
+function useOpenDialog() {
+    const setValue = (0, context_1.useContextSetValue)(context_2.DialogContext);
+    const closeDialog = (0, useCloseDialog_1.useCloseDialog)();
+    const openDialog = (0, react_1.useCallback)((options) => {
+        const id = randomId();
+        setValue((state) => {
+            return {
+                items: [
+                    ...state.items,
+                    Object.assign({ id, isOpen: true }, options),
+                ],
+            };
+        });
+        return { id, close: () => closeDialog(id) };
+    }, [setValue, closeDialog]);
+    return openDialog;
+}

package/dist/dialog/hooks/useOpenErrorDialog.d.ts

@@ -0,0 +1,2 @@
+import { AlertDialogOptions } from '@headless-adminapp/core/experience/dialog';
+export declare function useOpenErrorDialog(): (options: Omit<AlertDialogOptions, "type" | "onConfirm" | "onClose">) => void;

package/dist/dialog/hooks/useOpenErrorDialog.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOpenErrorDialog = useOpenErrorDialog;
+const react_1 = require("react");
+const useOpenDialog_1 = require("./useOpenDialog");
+function useOpenErrorDialog() {
+    const openDialog = (0, useOpenDialog_1.useOpenDialog)();
+    const openErrorDialog = (0, react_1.useCallback)((options) => {
+        const { close } = openDialog(Object.assign(Object.assign({ type: 'error' }, options), { onDismiss: () => {
+                close();
+            }, onConfirm: () => {
+                close();
+            } }));
+    }, [openDialog]);
+    return openErrorDialog;
+}

package/dist/dialog/hooks/useOpenPromptDialog.d.ts

@@ -0,0 +1,3 @@
+import { PromptDialogOptions } from '@headless-adminapp/core/experience/dialog';
+import { InferredSchemaType, SchemaAttributes } from '@headless-adminapp/core/schema';
+export declare function useOpenPromptDialog(): <SA extends SchemaAttributes = SchemaAttributes>(options: Omit<PromptDialogOptions<SA>, "type" | "onConfirm" | "onClose" | "onCancel">) => Promise<InferredSchemaType<SA> | null>;

package/dist/dialog/hooks/useOpenPromptDialog.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOpenPromptDialog = useOpenPromptDialog;
+const react_1 = require("react");
+const useOpenDialog_1 = require("./useOpenDialog");
+function useOpenPromptDialog() {
+    const openDialog = (0, useOpenDialog_1.useOpenDialog)();
+    const openPromptDialog = (0, react_1.useCallback)((options) => {
+        return new Promise((resolve) => {
+            const { close } = openDialog(Object.assign(Object.assign({ type: 'prompt' }, options), { onDismiss: () => {
+                    if (!options.allowDismiss) {
+                        return;
+                    }
+                    close();
+                    resolve(null);
+                }, onConfirm: (result) => {
+                    close();
+                    resolve(result);
+                }, onCancel: () => {
+                    close();
+                    resolve(null);
+                } }));
+        });
+    }, [openDialog]);
+    return openPromptDialog;
+}

package/dist/dialog/index.d.ts

@@ -0,0 +1,3 @@
+export { DialogContext, type DialogContextState, type DialogItemState, } from './context';
+export { DialogProvider } from './DialogProvider';
+export * from './hooks';

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

package/dist/form/FormValidationStringContext.d.ts

@@ -0,0 +1,12 @@
+export interface FormValidationStringSet {
+    required: string;
+    maxLength: string;
+    minLength: string;
+    invalidFormat: string;
+    invalidEmail: string;
+    invalidPhoneNumber: string;
+    atLeastOneRowRequired: string;
+}
+export declare const defaultFormValidationStrings: FormValidationStringSet;
+export declare const FormValidationStringContext: import("react").Context<FormValidationStringSet>;
+export declare function useFormValidationStrings(): FormValidationStringSet;

package/dist/form/FormValidationStringContext.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormValidationStringContext = exports.defaultFormValidationStrings = void 0;
+exports.useFormValidationStrings = useFormValidationStrings;
+const react_1 = require("react");
+exports.defaultFormValidationStrings = {
+    required: 'Required field must be filled in.',
+    maxLength: 'Maximum length exceeded.',
+    minLength: 'Minimum length not met.',
+    invalidFormat: 'Invalid format.',
+    invalidEmail: 'Invalid email.',
+    invalidPhoneNumber: 'Invalid phone number.',
+    atLeastOneRowRequired: 'At least one row required.',
+};
+exports.FormValidationStringContext = (0, react_1.createContext)(exports.defaultFormValidationStrings);
+function useFormValidationStrings() {
+    const context = (0, react_1.useContext)(exports.FormValidationStringContext);
+    return context;
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useDebouncedValue';
+export * from './useElementLayout';
+export * from './useIsMobile';
+export * from './useStorageState';
+export * from './useSystemColorScheme';

package/dist/hooks/index.js

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

package/dist/hooks/useDebouncedValue.d.ts

@@ -0,0 +1,3 @@
+export declare function useDebouncedValue<T = any>(value: T, wait: number, options?: {
+    leading: boolean;
+}): readonly [T, () => void];

package/dist/hooks/useDebouncedValue.js

@@ -0,0 +1,32 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDebouncedValue = useDebouncedValue;
+const react_1 = require("react");
+function useDebouncedValue(value, wait, options = { leading: false }) {
+    const [_value, setValue] = (0, react_1.useState)(value);
+    const mountedRef = (0, react_1.useRef)(false);
+    const timeoutRef = (0, react_1.useRef)(null);
+    const cooldownRef = (0, react_1.useRef)(false);
+    const cancel = () => window.clearTimeout(timeoutRef.current);
+    (0, react_1.useEffect)(() => {
+        if (mountedRef.current) {
+            if (!cooldownRef.current && options.leading) {
+                cooldownRef.current = true;
+                setValue(value);
+            }
+            else {
+                cancel();
+                timeoutRef.current = window.setTimeout(() => {
+                    cooldownRef.current = false;
+                    setValue(value);
+                }, wait);
+            }
+        }
+    }, [value, options.leading, wait]);
+    (0, react_1.useEffect)(() => {
+        mountedRef.current = true;
+        return cancel;
+    }, []);
+    return [_value, cancel];
+}

package/dist/hooks/useElementLayout.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from 'react';
+interface Size {
+    width: number;
+    height: number;
+}
+export declare function useElementSize(elementRef: RefObject<HTMLElement>, interval?: number): Size;
+export {};

package/dist/hooks/useElementLayout.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useElementSize = useElementSize;
+const react_1 = require("react");
+function useElementSize(elementRef, interval) {
+    const [size, setSize] = (0, react_1.useState)({ width: 0, height: 0 });
+    (0, react_1.useEffect)(() => {
+        function updateSize() {
+            if (elementRef.current) {
+                const element = elementRef.current;
+                const rect = element.getBoundingClientRect();
+                setSize((size) => {
+                    if (size.width === rect.width && size.height === rect.height) {
+                        return size;
+                    }
+                    return { width: rect.width, height: rect.height };
+                });
+            }
+        }
+        updateSize();
+        let intervalId;
+        if (interval) {
+            intervalId = setInterval(updateSize, interval);
+        }
+        window.addEventListener('resize', updateSize);
+        return () => {
+            window.removeEventListener('resize', updateSize);
+            if (intervalId) {
+                clearInterval(intervalId);
+            }
+        };
+    }, [elementRef, interval]);
+    return size;
+}

package/dist/hooks/useIsMobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): boolean;

package/dist/hooks/useIsMobile.js

@@ -0,0 +1,21 @@
+"use strict";
+'use client';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsMobile = useIsMobile;
+const debounce_1 = __importDefault(require("lodash/debounce"));
+const react_1 = require("react");
+function useIsMobile() {
+    const [isMobile, setIsMobile] = (0, react_1.useState)(false);
+    (0, react_1.useLayoutEffect)(() => {
+        const updateSize = () => {
+            setIsMobile(window.innerWidth < 768);
+        };
+        window.addEventListener('resize', (0, debounce_1.default)(updateSize, 250));
+        updateSize();
+        return () => window.removeEventListener('resize', updateSize);
+    }, []);
+    return isMobile;
+}

package/dist/hooks/useStorageState.d.ts

@@ -0,0 +1,2 @@
+import { Dispatch, SetStateAction } from 'react';
+export declare function useStorageState<S = undefined>(initialState: S, key: string, store?: Storage): [S, Dispatch<SetStateAction<S>>];

package/dist/hooks/useStorageState.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStorageState = useStorageState;
+const react_1 = require("react");
+function getStorageValue(key, store) {
+    const value = store.getItem(key);
+    if (value) {
+        return JSON.parse(value);
+    }
+    return undefined;
+}
+function setStorageValue(key, value, store) {
+    store.setItem(key, JSON.stringify(value));
+}
+function useStorageState(initialState, key, store = localStorage) {
+    var _a;
+    const [state, setState] = (0, react_1.useState)((_a = getStorageValue(key, store)) !== null && _a !== void 0 ? _a : initialState);
+    const setStoredState = (0, react_1.useCallback)((value) => {
+        setState((prevState) => {
+            const finalState = value instanceof Function ? value(prevState) : value;
+            setStorageValue(key, finalState, store);
+            return finalState;
+        });
+    }, [key, store]);
+    return [state, setStoredState];
+}

package/dist/hooks/useSystemColorScheme.d.ts

@@ -0,0 +1 @@
+export declare function useSystemColorScheme(): "light" | "dark";

package/dist/hooks/useSystemColorScheme.js

@@ -0,0 +1,27 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSystemColorScheme = useSystemColorScheme;
+const react_1 = require("react");
+const isSystemDarkMode = () => {
+    if (typeof window === 'undefined') {
+        return false;
+    }
+    return (window.matchMedia &&
+        window.matchMedia('(prefers-color-scheme: dark)').matches);
+};
+function useSystemColorScheme() {
+    const [systemColorScheme, setSystemColorScheme] = (0, react_1.useState)(isSystemDarkMode() ? 'dark' : 'light');
+    (0, react_1.useEffect)(() => {
+        setSystemColorScheme(isSystemDarkMode() ? 'dark' : 'light');
+        const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+        const handleChange = (e) => {
+            setSystemColorScheme(e.matches ? 'dark' : 'light');
+        };
+        mediaQuery.addEventListener('change', handleChange);
+        return () => {
+            mediaQuery.removeEventListener('change', handleChange);
+        };
+    }, []);
+    return systemColorScheme;
+}

package/dist/insights/context.d.ts

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

package/dist/insights/context.js

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