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

package/dist/route/index.js

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

package/dist/route/types.d.ts

@@ -0,0 +1,2 @@
+export interface ReadonlyURLSearchParams {
+}

package/dist/route/types.js

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

package/dist/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/dist/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/dist/store/ComponentStore.d.ts

@@ -0,0 +1,6 @@
+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;
+}

package/dist/store/ComponentStore.js

@@ -0,0 +1,23 @@
+"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 = {};
+    }
+    registerComponent(name, component) {
+        this.components[name] = component;
+    }
+    resolveComponent(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));
+        };
+    }
+}
+exports.ComponentStore = ComponentStore;

package/dist/store/EventManager.d.ts

@@ -0,0 +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>;
+    emit(key: string, ...args: any[]): any[];
+}

package/dist/store/EventManager.js

@@ -0,0 +1,42 @@
+"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 = {};
+    }
+    on(key, handler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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];
+            }
+        });
+    }
+    emit(key, ...args) {
+        var _a;
+        const handlers = ((_a = this.handlers[key]) !== null && _a !== void 0 ? _a : []);
+        return handlers.map((handler) => handler(...args));
+    }
+}
+exports.EventManager = EventManager;

package/dist/store/SchemaExperienceStore.d.ts

@@ -0,0 +1,32 @@
+import { LocalizedDataLookup } from '@headless-adminapp/core/attributes';
+import { EntityMainFormCommandItemExperience, Form, QuickCreateForm } from '@headless-adminapp/core/experience/form';
+import { SchemaExperience, SchemaExperienceMetadata } from '@headless-adminapp/core/experience/schema';
+import { CardView, EntityMainGridCommandItemExperience, SubGridCommandItemExperience, View } from '@headless-adminapp/core/experience/view';
+import { Schema, SchemaAttributes, SchemaMetadata } from '@headless-adminapp/core/schema';
+import { ISchemaExperienceStore, ISchemaStore } from '@headless-adminapp/core/store';
+export declare function getDefaultCardView<S extends SchemaAttributes = SchemaAttributes>(schema: Schema<S>): CardView<S>;
+interface SchemaExperienceStoreOptions {
+    schemaStore: ISchemaStore;
+}
+export declare class SchemaExperienceStore implements ISchemaExperienceStore {
+    protected options: SchemaExperienceStoreOptions;
+    private experiences;
+    constructor(options: SchemaExperienceStoreOptions);
+    register<S extends SchemaAttributes = SchemaAttributes>(experience: SchemaExperience<S>): void;
+    getExperience<S extends SchemaAttributes = SchemaAttributes>(logicalName: string): Promise<SchemaExperience<S>>;
+    getPublicViewLookup(logicalName: string, viewIds?: string[]): Promise<LocalizedDataLookup[]>;
+    getAssociatedViewLookup(logicalName: string, viewIds?: string[]): Promise<LocalizedDataLookup[]>;
+    getPublicView<S extends SchemaAttributes = SchemaAttributes>(logicalName: string, viewId?: string, viewIds?: string[]): Promise<View<S>>;
+    getAssociatedView<S extends SchemaAttributes = SchemaAttributes>(logicalName: string, viewId?: string, viewIds?: string[]): Promise<View<S>>;
+    getViewLookupV2<S extends SchemaAttributes = SchemaAttributes>(logicalName: string, viewId?: string): Promise<View<S>>;
+    getDefaultViewId(logicalName: string): Promise<string>;
+    getDefaultViewLookupId(logicalName: string): Promise<string>;
+    getForm<S extends SchemaAttributes = SchemaAttributes>(logicalName: string, formId: string): Promise<Form<S>>;
+    getQuickCreateForm<S extends SchemaAttributes = SchemaAttributes>(logicalName: string, formId: string): Promise<QuickCreateForm<S>>;
+    getViewCommands(logicalName: string): Promise<EntityMainGridCommandItemExperience[][]>;
+    getFormCommands(logicalName: string): Promise<EntityMainFormCommandItemExperience[][]>;
+    getSubgridCommands(logicalName: string): Promise<SubGridCommandItemExperience[][]>;
+    getSchemaMetadataList(): SchemaMetadata[];
+    getExperienceSchemaMetadatList(): Promise<SchemaExperienceMetadata[]>;
+}
+export {};

package/dist/store/SchemaExperienceStore.js

@@ -0,0 +1,264 @@
+"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.SchemaExperienceStore = void 0;
+exports.getDefaultCardView = getDefaultCardView;
+function getDefaultCardView(schema) {
+    return {
+        primaryColumn: schema.primaryAttribute,
+    };
+}
+class SchemaExperienceStore {
+    constructor(options) {
+        this.options = options;
+        this.experiences = {};
+    }
+    register(experience) {
+        for (const view of Object.values(experience.views)) {
+            if (!view.id) {
+                throw new Error('View id is required');
+            }
+            if (!view.name) {
+                throw new Error('View name is required');
+            }
+            if (view.logicalName !== experience.logicalName) {
+                throw new Error('View logicalName must match experience logicalName');
+            }
+        }
+        this.experiences[experience.logicalName] = experience;
+    }
+    getExperience(logicalName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const experience = this.experiences[logicalName];
+            if (!experience) {
+                throw new Error(`Experience for ${logicalName} not found`);
+            }
+            return experience;
+        });
+    }
+    getPublicViewLookup(logicalName, viewIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const experience = yield this.getExperience(logicalName);
+            let views = experience.views;
+            if (viewIds === null || viewIds === void 0 ? void 0 : viewIds.length) {
+                views = views.filter((view) => viewIds.includes(view.id));
+            }
+            if (!views.length) {
+                views = experience.views.filter((x) => x.id === experience.defaultViewId);
+            }
+            return views.map((view) => ({
+                id: view.id,
+                name: view.name,
+                localizedNames: view.localizedNames,
+            }));
+        });
+    }
+    getAssociatedViewLookup(logicalName, viewIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const experience = yield this.getExperience(logicalName);
+            let associatedViews = experience.associatedViews;
+            if (viewIds === null || viewIds === void 0 ? void 0 : viewIds.length) {
+                associatedViews = associatedViews.filter((view) => viewIds.includes(view.id));
+            }
+            if (!associatedViews.length) {
+                associatedViews = experience.associatedViews.filter((x) => x.id === experience.defaultAssociatedViewId);
+            }
+            return associatedViews.map((view) => ({
+                id: view.id,
+                name: view.name,
+                localizedNames: view.localizedNames,
+            }));
+        });
+    }
+    getPublicView(logicalName, viewId, viewIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const experience = yield this.getExperience(logicalName);
+            const availableViewLookup = yield this.getPublicViewLookup(logicalName, viewIds);
+            let validViewIds = availableViewLookup.map((x) => x.id);
+            if (!validViewIds.length) {
+                validViewIds = [experience.defaultViewId];
+            }
+            if (!viewId) {
+                viewId = experience.defaultViewId;
+            }
+            if (!validViewIds.includes(viewId)) {
+                viewId = validViewIds[0];
+            }
+            let view = experience.views.find((v) => v.id === viewId);
+            if (!view) {
+                throw new Error(`View ${viewId} not found`);
+            }
+            let viewExperience = view.experience;
+            if (typeof viewExperience === 'function') {
+                viewExperience = yield viewExperience();
+            }
+            if (!viewExperience.card) {
+                viewExperience.card = getDefaultCardView(this.options.schemaStore.getSchema(logicalName));
+            }
+            return {
+                id: view.id,
+                name: view.name,
+                logicalName: view.logicalName,
+                localizedNames: view.localizedNames,
+                experience: viewExperience,
+            };
+        });
+    }
+    getAssociatedView(logicalName, viewId, viewIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const experience = yield this.getExperience(logicalName);
+            const availableViewLookup = yield this.getAssociatedViewLookup(logicalName, viewIds);
+            let validViewIds = availableViewLookup.map((x) => x.id);
+            if (!validViewIds.length) {
+                validViewIds = [experience.defaultViewId];
+            }
+            if (!viewId) {
+                viewId = experience.defaultAssociatedViewId;
+            }
+            if (!validViewIds.includes(viewId)) {
+                viewId = validViewIds[0];
+            }
+            let view = experience.associatedViews.find((v) => v.id === viewId);
+            if (!view) {
+                throw new Error(`View ${viewId} not found`);
+            }
+            let viewExperience = view.experience;
+            if (typeof viewExperience === 'function') {
+                viewExperience = yield viewExperience();
+            }
+            if (!viewExperience.card) {
+                viewExperience.card = getDefaultCardView(this.options.schemaStore.getSchema(logicalName));
+            }
+            return {
+                id: view.id,
+                name: view.name,
+                logicalName: view.logicalName,
+                localizedNames: view.localizedNames,
+                experience: viewExperience,
+            };
+        });
+    }
+    getViewLookupV2(logicalName, viewId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const experience = yield this.getExperience(logicalName);
+            if (!viewId) {
+                viewId = experience.defaultViewId;
+            }
+            const view = experience.lookups.find((v) => v.id === viewId);
+            if (!view) {
+                throw new Error(`Lookup ${viewId} not found`);
+            }
+            let viewExperience = view.experience;
+            if (typeof viewExperience === 'function') {
+                viewExperience = yield viewExperience();
+            }
+            return {
+                id: view.id,
+                name: view.name,
+                logicalName: view.logicalName,
+                experience: viewExperience,
+            };
+        });
+    }
+    getDefaultViewId(logicalName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const experience = yield this.getExperience(logicalName);
+            return experience.defaultViewId;
+        });
+    }
+    getDefaultViewLookupId(logicalName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const experience = yield this.getExperience(logicalName);
+            return experience.defaultLookupId;
+        });
+    }
+    getForm(logicalName, formId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const experience = yield this.getExperience(logicalName);
+            if (!formId) {
+                formId = experience.defaultFormId;
+            }
+            const form = experience.forms.find((f) => f.id === formId);
+            if (!form) {
+                throw new Error(`Form ${formId} not found`);
+            }
+            let formExperience = form.experience;
+            if (typeof formExperience === 'function') {
+                formExperience = yield formExperience();
+            }
+            return {
+                id: form.id,
+                name: form.name,
+                logicalName: form.logicalName,
+                experience: formExperience,
+            };
+        });
+    }
+    getQuickCreateForm(logicalName, formId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const experience = yield this.getExperience(logicalName);
+            const form = experience.quickCreateForms.find((f) => f.id === formId);
+            if (!form) {
+                throw new Error(`Quick create form ${formId} not found`);
+            }
+            let formExperience = form.experience;
+            if (typeof formExperience === 'function') {
+                formExperience = yield formExperience();
+            }
+            return {
+                id: form.id,
+                name: form.name,
+                logicalName: form.logicalName,
+                experience: formExperience,
+            };
+        });
+    }
+    getViewCommands(logicalName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const experience = yield this.getExperience(logicalName);
+            return experience.viewCommands;
+        });
+    }
+    getFormCommands(logicalName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const experience = yield this.getExperience(logicalName);
+            return experience.formCommands;
+        });
+    }
+    getSubgridCommands(logicalName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const experience = yield this.getExperience(logicalName);
+            return experience.subgridCommands;
+        });
+    }
+    getSchemaMetadataList() {
+        const schemas = this.options.schemaStore.getAllSchema();
+        return Object.values(schemas).map((schema) => ({
+            logicalName: schema.logicalName,
+            label: schema.label,
+            pluralLabel: schema.pluralLabel,
+            description: schema.description,
+            localizedDescriptions: schema.localizedDescriptions,
+            localizedLabels: schema.localizedLabels,
+            localizedPluralLabels: schema.localizedPluralLabels,
+        }));
+    }
+    getExperienceSchemaMetadatList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schemaMetadatas = this.getSchemaMetadataList();
+            return schemaMetadatas.map((schemaMetadata) => {
+                var _a;
+                return (Object.assign(Object.assign({}, schemaMetadata), { icon: (_a = this.experiences[schemaMetadata.logicalName]) === null || _a === void 0 ? void 0 : _a.icon }));
+            });
+        });
+    }
+}
+exports.SchemaExperienceStore = SchemaExperienceStore;

package/dist/store/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ClientAppStore';
+export * from './ComponentStore';
+export * from './EventManager';
+export * from './SchemaExperienceStore';

package/dist/store/index.js

@@ -0,0 +1,20 @@
+"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("./ClientAppStore"), exports);
+__exportStar(require("./ComponentStore"), exports);
+__exportStar(require("./EventManager"), exports);
+__exportStar(require("./SchemaExperienceStore"), exports);

package/dist/toast-notification/ToastNotificationProvider.d.ts

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

package/dist/toast-notification/ToastNotificationProvider.js

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

package/dist/toast-notification/context.d.ts

@@ -0,0 +1,15 @@
+export interface ToastNotificationItem {
+    id: string;
+    isOpen: boolean;
+    text: string;
+    title?: string;
+    actions?: {
+        text: string;
+        onClick: () => void;
+    }[];
+    type?: 'info' | 'success' | 'warning' | 'error';
+}
+export interface ToastNotificationContextState {
+    items: ToastNotificationItem[];
+}
+export declare const ToastNotificationContext: import("react").Context<import("../mutable/context").ContextValue<ToastNotificationContextState>>;

package/dist/toast-notification/context.js

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

package/dist/toast-notification/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './useCloseToastNotification';
+export * from './useOpenToastNotification';
+export * from './useToastNotificationItems';

package/dist/toast-notification/hooks/index.js

@@ -0,0 +1,19 @@
+"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("./useCloseToastNotification"), exports);
+__exportStar(require("./useOpenToastNotification"), exports);
+__exportStar(require("./useToastNotificationItems"), exports);

package/dist/toast-notification/hooks/useCloseToastNotification.d.ts

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

package/dist/toast-notification/hooks/useCloseToastNotification.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCloseToastNotification = useCloseToastNotification;
+const react_1 = require("react");
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+function useCloseToastNotification() {
+    const setValue = (0, context_1.useContextSetValue)(context_2.ToastNotificationContext);
+    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/toast-notification/hooks/useOpenToastNotification.d.ts

@@ -0,0 +1,5 @@
+import { ToastNotificationItem } from '../context';
+export declare function useOpenToastNotification(): (options: Omit<ToastNotificationItem, "id" | "isOpen">) => {
+    id: string;
+    close: () => void;
+};

package/dist/toast-notification/hooks/useOpenToastNotification.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOpenToastNotification = useOpenToastNotification;
+const react_1 = require("react");
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+const useCloseToastNotification_1 = require("./useCloseToastNotification");
+function randomId() {
+    return Math.random().toString(36).substring(2);
+}
+function useOpenToastNotification() {
+    const setValue = (0, context_1.useContextSetValue)(context_2.ToastNotificationContext);
+    const closeDialog = (0, useCloseToastNotification_1.useCloseToastNotification)();
+    const openToastNotification = (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 openToastNotification;
+}

package/dist/toast-notification/hooks/useToastNotificationItems.d.ts

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

package/dist/toast-notification/hooks/useToastNotificationItems.js

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

package/dist/toast-notification/index.d.ts

@@ -0,0 +1,3 @@
+export { ToastNotificationContext, type ToastNotificationContextState, type ToastNotificationItem, } from './context';
+export { ToastNotificationProvider } from './ToastNotificationProvider';
+export * from './hooks';

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