@headless-adminapp/app 0.0.17-alpha.8 → 1.0.0

package/metadata/hooks/useExperienceViewSubgridCommands.d.ts

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

package/metadata/hooks/useExperienceViewSubgridCommands.js

@@ -1,13 +1,4 @@
 "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 app_1 = require("@headless-adminapp/app/app");
@@ -16,16 +7,16 @@ const useExperienceStore_1 = require("./useExperienceStore");
 /** @todo move in different dir */
 function useExperienceViewSubgridCommands(logicalName) {
     const experienceStore = (0, useExperienceStore_1.useExperienceStore)();
-    const { app: { subgridCommands }, } = (0, app_1.useAppContext)();
+    const { appExperience: { subgridCommands }, } = (0, app_1.useAppContext)();
     const { data: commands } = (0, react_query_1.useQuery)({
         queryKey: ['experience-schema-view-subgrid-commands', logicalName],
-        queryFn: () => __awaiter(this, void 0, void 0, function* () {
-            let commands = yield experienceStore.getSubgridCommands(logicalName);
+        queryFn: async () => {
+            let commands = await experienceStore.getSubgridCommands(logicalName);
             if (!commands) {
                 commands = subgridCommands;
             }
-            return [];
-        }),
+            return commands ?? [];
+        },
         initialData: [],
     });
     return {

package/metadata/hooks/useMetadata.d.ts

@@ -1,10 +1,11 @@
-import { SchemaAttributes } from '@headless-adminapp/core/schema';
-export declare function useMetadata(): {
-    schemas: Record<string, import("@headless-adminapp/core/schema").Schema<SchemaAttributes>>;
-    schemaLoading: boolean;
-    /*** @deprecated */
-    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;
-};
+import type { AppExperience } from '@headless-adminapp/core/experience/app';
+import type { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import type { ISchemaExperienceStore, ISchemaStore } from '@headless-adminapp/core/store';
+interface UseMetadataResult {
+    schemas: Record<string, Schema<SchemaAttributes>>;
+    schemaStore: ISchemaStore<SchemaAttributes>;
+    appExperience: AppExperience;
+    experienceStore: ISchemaExperienceStore;
+}
+export declare function useMetadata(): UseMetadataResult;
+export {};

package/metadata/hooks/useMetadata.js

@@ -6,25 +6,13 @@ 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 appExperience = (0, context_1.useContextSelector)(context_2.MetadataContext, (state) => state.appExperience);
     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();
-    /*** @deprecated */
-    const getSchema = (0, react_1.useCallback)((logicalName) => {
-        return schemaStore.getSchema(logicalName);
-    }, [schemaStore]);
-    return {
+    return (0, react_1.useMemo)(() => ({
         schemas,
-        schemaLoading,
-        /*** @deprecated */
-        getSchema,
         schemaStore,
-        appStore,
+        appExperience,
         experienceStore,
-    };
+    }), [schemas, schemaStore, appExperience, experienceStore]);
 }

package/metadata/hooks/useSchema.d.ts

@@ -1,2 +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>;
+export declare function useSchema<S extends SchemaAttributes = SchemaAttributes>(logicalName: string): import("@headless-adminapp/core/schema").Schema<S> | null;

package/metadata/hooks/useSchema.js

@@ -4,5 +4,8 @@ exports.useSchema = useSchema;
 const useMetadata_1 = require("./useMetadata");
 function useSchema(logicalName) {
     const { schemaStore } = (0, useMetadata_1.useMetadata)();
+    if (!schemaStore.hasSchema(logicalName)) {
+        return null;
+    }
     return schemaStore.getSchema(logicalName);
 }

package/mutable/context.d.ts

@@ -4,6 +4,9 @@ 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 useContextValue<T>(context: React.Context<ContextValue<T>>): {
+    current: 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;

package/mutable/context.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useContextSelectorInternal = void 0;
 exports.createContext = createContext;
 exports.useCreateContextStore = useCreateContextStore;
+exports.useContextValue = useContextValue;
 exports.useContextSelector = useContextSelector;
 exports.useContextSetValue = useContextSetValue;
 exports.useContextValueSetter = useContextValueSetter;
@@ -18,6 +19,13 @@ function useCreateContextStore(initialValue) {
     const [state] = (0, react_1.useState)(() => createContextValue(initialValue));
     return state;
 }
+function useContextValue(context) {
+    const contextValue = (0, react_1.useContext)(context);
+    if (!contextValue) {
+        throw new Error('useContextValue must be used within a Provider');
+    }
+    return contextValue.value;
+}
 function useContextSelector(context, selector) {
     const contextValue = (0, react_1.useContext)(context);
     if (!contextValue) {

package/mutable/utils.js

@@ -12,20 +12,13 @@ function createMutableValue(initialValue, isArray) {
         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));
-                }
+                value = value(storeValue.current);
+            }
+            if (isArray) {
+                storeValue.current = value;
             }
             else {
-                if (isArray) {
-                    storeValue.current = value;
-                }
-                else {
-                    storeValue.current = Object.assign(Object.assign({}, storeValue.current), value);
-                }
+                storeValue.current = { ...storeValue.current, ...value };
             }
             listeners.forEach((listener) => listener(storeValue.current));
         },

package/navigation/hooks/useOpenForm.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useOpenForm = useOpenForm;
+const defaultParameters_1 = require("@headless-adminapp/app/dataform/utils/defaultParameters");
 const app_1 = require("@headless-adminapp/core/experience/app");
 const react_1 = require("react");
 const hooks_1 = require("../../route/hooks/");
@@ -14,6 +15,9 @@ function useOpenForm() {
             type: app_1.PageType.EntityForm,
             id: options.id,
         });
+        if (options.parameters) {
+            (0, defaultParameters_1.setFormDefaultParameters)(options.logicalName, options.parameters);
+        }
         if (options.replace) {
             router.replace(path);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@headless-adminapp/app",
-  "version": "0.0.17-alpha.8",
+  "version": "1.0.0",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -16,13 +16,7 @@
   "bugs": {
     "url": "https://github.com/headless-adminapp/adminapp/issues"
   },
-  "scripts": {
-    "build": "tsc",
-    "ts-check": "tsc --noEmit",
-    "copy-files": "cp package.json dist && cp src/index.css dist",
-    "prepublishOnly": "pnpm run build && pnpm run copy-files",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
+  "scripts": {},
   "keywords": [],
   "author": "",
   "license": "ISC",
@@ -33,10 +27,12 @@
     "dayjs": "^1.11.13",
     "exceljs": "^4.4.0",
     "json-to-csv-export": "^2.1.1",
+    "libphonenumber-js": "1.11.20",
     "lodash": "^4.17.21",
     "react-custom-scrollbars-2": "^4.5.0",
     "react-hook-form": "7.52.2",
+    "uuid": "11.0.3",
     "yup": "^1.4.0"
   },
-  "gitHead": "0c369830a0ba4aa5744cc307f8947ae9660980c4"
-}
+  "gitHead": "2b03aadc605acf3bc18270afce4cbd9072b0b6ae"
+}

package/providers/PageEntityFormProvider/index.d.ts

@@ -1,11 +1,15 @@
 import { EntityMainFormCommandItemExperience, Form } from '@headless-adminapp/core/experience/form';
 import { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
 import { PropsWithChildren } from 'react';
+import { RetriveRecordFn } from '../../dataform/DataFormProvider/types';
+import { SaveRecordFn } from '../../dataform/utils/saveRecord';
 interface PageEntityFormProviderProps<S extends SchemaAttributes> {
     schema: Schema<S>;
     form: Form<S>;
     recordId?: string;
     commands: EntityMainFormCommandItemExperience[][];
+    retriveRecordFn?: RetriveRecordFn<S>;
+    saveRecordFn?: SaveRecordFn;
 }
-export declare function PageEntityFormProvider<S extends SchemaAttributes>({ schema, form, recordId, children, commands, }: PropsWithChildren<PageEntityFormProviderProps<S>>): import("react/jsx-runtime").JSX.Element;
+export declare function PageEntityFormProvider<S extends SchemaAttributes>({ schema, form, recordId, children, commands, retriveRecordFn, saveRecordFn, }: PropsWithChildren<PageEntityFormProviderProps<S>>): import("react/jsx-runtime").JSX.Element;
 export {};

package/providers/PageEntityFormProvider/index.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PageEntityFormProvider = PageEntityFormProvider;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const DataFormProvider_1 = require("../../dataform/DataFormProvider");
-function PageEntityFormProvider({ schema, form, recordId, children, commands, }) {
-    return ((0, jsx_runtime_1.jsx)(DataFormProvider_1.DataFormProvider, { schema: schema, form: form, recordId: recordId, commands: commands, children: children }));
+function PageEntityFormProvider({ schema, form, recordId, children, commands, retriveRecordFn, saveRecordFn, }) {
+    return ((0, jsx_runtime_1.jsx)(DataFormProvider_1.DataFormProvider, { schema: schema, form: form, recordId: recordId, commands: commands, retriveRecordFn: retriveRecordFn, saveRecordFn: saveRecordFn, children: children }));
 }

package/recordset/hooks/useRecordSetResult.js

@@ -1,13 +1,4 @@
 "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.useRecordSetResult = useRecordSetResult;
 const react_query_1 = require("@tanstack/react-query");
@@ -29,26 +20,25 @@ function useRecordSetResult() {
     }, [context.logicalName, schemaStore]);
     const cardView = context.cardView;
     const columns = (0, react_1.useMemo)(() => {
-        var _a;
         if (!cardView) {
             return [];
         }
         return Array.from(new Set([
             cardView.primaryColumn,
             cardView.avatarColumn,
-            ...((_a = cardView.secondaryColumns) !== null && _a !== void 0 ? _a : [])
+            ...(cardView.secondaryColumns ?? [])
                 .filter((x) => !x.expandedKey)
                 .map((x) => x.name),
         ])).filter(Boolean);
     }, [cardView]);
     const { isPending, data, error } = (0, react_query_1.useQuery)({
         queryKey: ['data', 'recordset', context.logicalName, context.ids, columns],
-        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+        queryFn: async () => {
             if (!context.logicalName || !context.ids.length || !cardView) {
                 return [];
             }
             const schema = schemaStore.getSchema(context.logicalName);
-            const result = yield dataService.retriveRecords({
+            const result = await dataService.retriveRecords({
                 logicalName: context.logicalName,
                 filter: {
                     type: 'and',
@@ -66,7 +56,7 @@ function useRecordSetResult() {
             });
             const sortedData = (0, lodash_1.sortBy)(result.records, (x) => context.ids.indexOf(x[schema.idAttribute]));
             return sortedData;
-        }),
+        },
     });
     if (error) {
         console.error(error);

package/route/RouteProvider.d.ts

@@ -7,7 +7,7 @@ export interface RouteProviderProps {
     pathname: string;
     searchParams: ReadonlyURLSearchParams;
     basePath?: string;
-    routeResolver: RouteResolver;
-    isRouteActive: IsRouteActive;
+    routeResolver?: RouteResolver;
+    isRouteActive?: IsRouteActive;
 }
 export declare const RouteProvider: FC<PropsWithChildren<RouteProviderProps>>;

package/route/RouteProvider.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouteProvider = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
+const route_1 = require("@headless-adminapp/core/experience/route");
 const react_1 = require("react");
 const context_1 = require("./context");
-const RouteProvider = ({ children, pathname, router, searchParams, basePath, routeResolver, isRouteActive, }) => {
+const defaultRouteResolver = (0, route_1.createRouteResolver)(route_1.defaultRouteInfo);
+const defaultIsRouteActive = (0, route_1.createIsRouteActive)(route_1.defaultRouteInfo);
+const RouteProvider = ({ children, pathname, router, searchParams, basePath, routeResolver = defaultRouteResolver, isRouteActive = defaultIsRouteActive, }) => {
     const basePathRef = (0, react_1.useRef)(basePath);
     basePathRef.current = basePath;
     const routeResolverRef = (0, react_1.useRef)(routeResolver);

package/store/ClientAppStore.js

@@ -1,30 +1,17 @@
 "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 = {};
-    }
+    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;
-        });
+    async getApp(id) {
+        const app = this.apps[id];
+        if (!app) {
+            throw new Error(`App Experience for ${id} not found`);
+        }
+        return app;
     }
 }
 exports.ClientAppStore = ClientAppStore;

package/store/ComponentStore.d.ts

@@ -2,5 +2,5 @@ import { IComponentStore } from '@headless-adminapp/core/store';
 export declare class ComponentStore implements IComponentStore {
     private components;
     registerComponent<T>(name: string, component: T): void;
-    resolveComponent<T>(name: string): T;
+    getComponent<T>(name: string): T | null;
 }

package/store/ComponentStore.js

@@ -1,23 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComponentStore = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
 class ComponentStore {
-    constructor() {
-        this.components = {};
-    }
+    components = {};
     registerComponent(name, component) {
         this.components[name] = component;
     }
-    resolveComponent(name) {
+    getComponent(name) {
         const self = this;
-        return function (props) {
-            if (!self.components[name]) {
-                throw new Error(`Component ${name} is not registered`);
-            }
-            const Component = self.components[name];
-            return (0, jsx_runtime_1.jsx)(Component, Object.assign({}, props));
-        };
+        if (!self.components[name]) {
+            return null;
+        }
+        return self.components[name];
     }
 }
 exports.ComponentStore = ComponentStore;

package/store/EventManager.d.ts

@@ -1,7 +1,7 @@
 import { IEventManager } from '@headless-adminapp/core/store';
 export declare class EventManager implements IEventManager {
     private handlers;
-    on<T>(key: string, handler: T): Promise<void>;
-    off<T>(key: string, handler: T): Promise<void>;
+    on<T>(key: string, handler: T): void;
+    off<T>(key: string, handler: T): void;
     emit(key: string, ...args: any[]): any[];
 }

package/store/EventManager.js

@@ -1,41 +1,25 @@
 "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.EventManager = void 0;
 class EventManager {
-    constructor() {
-        this.handlers = {};
-    }
+    handlers = {};
     on(key, handler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.handlers[key]) {
-                this.handlers[key] = [];
-            }
-            this.handlers[key].push(handler);
-        });
+        if (!this.handlers[key]) {
+            this.handlers[key] = [];
+        }
+        this.handlers[key].push(handler);
     }
     off(key, handler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.handlers[key]) {
-                return;
-            }
-            this.handlers[key] = this.handlers[key].filter((h) => h !== handler);
-            if (this.handlers[key].length === 0) {
-                delete this.handlers[key];
-            }
-        });
+        if (!this.handlers[key]) {
+            return;
+        }
+        this.handlers[key] = this.handlers[key].filter((h) => h !== handler);
+        if (this.handlers[key].length === 0) {
+            delete this.handlers[key];
+        }
     }
     emit(key, ...args) {
-        var _a;
-        const handlers = ((_a = this.handlers[key]) !== null && _a !== void 0 ? _a : []);
+        const handlers = (this.handlers[key] ?? []);
         return handlers.map((handler) => handler(...args));
     }
 }