@plitzi/sdk-shared 0.30.19

package/dist/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,11 @@
+//#region \0rolldown/runtime.js
+var e = Object.defineProperty, t = (t, n) => {
+	let r = {};
+	for (var i in t) e(r, i, {
+		get: t[i],
+		enumerable: !0
+	});
+	return n || e(r, Symbol.toStringTag, { value: "Module" }), r;
+};
+//#endregion
+export { t as __exportAll };

package/dist/builder/contexts/BuilderContext.d.ts

@@ -0,0 +1,61 @@
+import { ComponentPluginWithHOC, DropPosition, Element, EventBridgeEvent, PluginBuilder, Schema, Style, StyleThemeMode } from '../../types';
+import { Dispatch, SetStateAction } from 'react';
+export type BuilderContextValue = {
+    theme: StyleThemeMode;
+    setTheme: Dispatch<SetStateAction<StyleThemeMode>>;
+    mode: 'normal' | 'template' | 'segment';
+    schemaName: string;
+    setMultiPagesMode: Dispatch<SetStateAction<boolean>>;
+    multiPagesMode: boolean;
+    hasMultiPages: boolean;
+    baseContext: {
+        baseElementId: string;
+    };
+    baseElementIdOriginal: string;
+    builderSetBaseContext: (id?: string) => void;
+    builderElementPermissions: {
+        (element: Element, path: string, defaultValue?: boolean): boolean;
+        (element: Element, path?: undefined, defaultValue?: boolean): PluginBuilder;
+        (element: Element, path?: string, defaultValue?: boolean): boolean | PluginBuilder;
+    };
+    builderHandler: (event: EventBridgeEvent, ...data: unknown[]) => void;
+    updateElement: (elementId: string, attributeKey: string, attributeValue: unknown, category?: 'attributes' | 'definition') => void;
+    elementAsTemplate: (cdnIdentifier: string, schema: Schema, style: Style, name: string, description: string, element: Element) => Promise<void>;
+    builderGetBaseElement: (otherBaseElementId?: string) => undefined | {
+        data: Element;
+        Plugin: ComponentPluginWithHOC | Record<string, ComponentPluginWithHOC>;
+    };
+    builderDropElement: {
+        (type: 'add##plitzi-template', data: {
+            elements: Record<string, Element>;
+            baseElement?: Element;
+            style: Style;
+            variables: Schema['variables'];
+        }, dropPosition: DropPosition, toElementId: string, rootId?: string): boolean;
+        <T extends string>(type: `add##${Exclude<T, 'plitzi-template'>}`, data: {
+            id: string;
+            element: Element;
+        }, dropPosition: DropPosition, toElementId: string, rootId?: string): boolean;
+        <T extends string>(type: `move##${Exclude<T, 'plitzi-template'>}`, data: {
+            id: string;
+            parentId: string;
+            element: Element;
+        }, dropPosition: DropPosition, toElementId: string, rootId?: string): boolean;
+        (type: string, data: {
+            elements: Record<string, Element>;
+            baseElement?: Element;
+            style: Style;
+            variables: Schema['variables'];
+        } | {
+            id: string;
+            element: Element;
+        } | {
+            id: string;
+            parentId: string;
+            element: Element;
+        }, dropPosition: DropPosition, toElementId: string, rootId?: string): boolean;
+    };
+    builderSetElementVisibility: (elementId: string, visibility: boolean) => void;
+};
+declare const BuilderContext: import('react').Context<BuilderContextValue>;
+export default BuilderContext;

package/dist/builder/contexts/BuilderContext.mjs

@@ -0,0 +1,5 @@
+import { createContext as e } from "react";
+var t = e({});
+t.displayName = "BuilderContext";
+//#endregion
+export { t as default };

package/dist/builder/contexts/index.d.ts

@@ -0,0 +1,3 @@
+import { default as BuilderContext } from './BuilderContext';
+export * from './BuilderContext';
+export { BuilderContext };

package/dist/builder/contexts/index.mjs

@@ -0,0 +1,6 @@
+import { __exportAll as e } from "../../_virtual/_rolldown/runtime.mjs";
+import t from "./BuilderContext.mjs";
+//#region src/builder/contexts/index.ts
+var n = /* @__PURE__ */ e({ BuilderContext: () => t });
+//#endregion
+export { t as BuilderContext, n as contexts_exports };

package/dist/builder/index.d.ts

@@ -0,0 +1,3 @@
+import * as contexts from './contexts';
+export * from './contexts';
+export { contexts };

package/dist/builder/index.mjs

@@ -0,0 +1,3 @@
+import e from "./contexts/BuilderContext.mjs";
+import { contexts_exports as t } from "./contexts/index.mjs";
+export { e as BuilderContext, t as contexts };

package/dist/collections/CollectionContext.d.ts

@@ -0,0 +1,2 @@
+declare const CollectionContext: import('react').Context<import('..').SdkCollectionContextValue>;
+export default CollectionContext;

package/dist/collections/CollectionContext.mjs

@@ -0,0 +1,5 @@
+import { createContext as e } from "react";
+var t = e({});
+t.displayName = "CollectionContext";
+//#endregion
+export { t as default };

package/dist/collections/index.d.ts

@@ -0,0 +1,3 @@
+import { default as CollectionContext } from './CollectionContext';
+export * from './CollectionContext';
+export { CollectionContext };

package/dist/collections/index.mjs

@@ -0,0 +1,2 @@
+import e from "./CollectionContext.mjs";
+export { e as CollectionContext };

package/dist/dataSource/DataSourceContext.d.ts

@@ -0,0 +1,3 @@
+import { DataSourceContextValue } from '../types';
+declare const DataSourceContext: import('react').Context<DataSourceContextValue>;
+export default DataSourceContext;

package/dist/dataSource/DataSourceContext.mjs

@@ -0,0 +1,5 @@
+import { createContext as e } from "react";
+var t = e({});
+t.displayName = "DataSourceContext";
+//#endregion
+export { t as default };

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

@@ -0,0 +1,3 @@
+import { default as useDataSource } from './useDataSource';
+export * from './useDataSource';
+export { useDataSource };

package/dist/dataSource/hooks/index.mjs

@@ -0,0 +1,2 @@
+import e from "./useDataSource.mjs";
+export { e as useDataSource };

package/dist/dataSource/hooks/useDataSource.d.ts

@@ -0,0 +1,20 @@
+import { SourceMeta } from '../../types';
+import { Context } from 'react';
+export type UseDataSourceMode = 'write' | 'read';
+export type UseDataSourceFilter = 'soft' | 'hard';
+export type UseDataSourceProps<T extends UseDataSourceMode> = {
+    id?: string;
+    fields?: SourceMeta['fields'];
+    mode: T;
+    sourceFilter?: string[];
+    filterMode?: UseDataSourceFilter;
+} & (T extends 'read' ? {
+    name?: string;
+    source?: string;
+} : {
+    name: string;
+    source: string;
+});
+declare function useDataSource<T = unknown>(props: UseDataSourceProps<'read'>): Record<string, T>;
+declare function useDataSource<T = unknown>(props: UseDataSourceProps<'write'>): [Context<T>, string];
+export default useDataSource;

package/dist/dataSource/hooks/useDataSource.mjs

@@ -0,0 +1,45 @@
+import { emptyObject as e, makeId as t } from "../../helpers/utils.mjs";
+import n from "../DataSourceContext.mjs";
+import { use as r, useEffect as i, useMemo as a, useRef as o } from "react";
+//#region src/dataSource/hooks/useDataSource.ts
+function s({ id: s = "", source: c, name: l, fields: u = [], mode: d = "write", sourceFilter: f = [], filterMode: p = "soft" }) {
+	let { addSource: m, getSources: h, updateFields: g, removeSource: _ } = r(n), v = o(!1), y = a(() => `${s}_${t(8)}`, [s]), b = o(void 0), x = o({});
+	if (d === "write" && (!l || !c)) throw Error("Name and Source are required in write mode");
+	if (d === "write" && !v.current && (v.current = !0, b.current = m(y, {
+		id: s,
+		source: c,
+		name: l,
+		fields: u
+	})), i(() => (d === "write" && !v.current && (v.current = !0, b.current = m(y, {
+		id: s,
+		source: c,
+		name: l,
+		fields: u
+	})), () => {
+		v.current = !1, _(y);
+	}), [y]), i(() => {
+		d === "write" && g(y, u);
+	}, [
+		u,
+		y,
+		g,
+		d
+	]), d === "write") return [b.current, y];
+	if (p === "hard" && !f.length) return e;
+	let S = Object.values(h());
+	f.length && (S = S.filter((e) => !f.length || !e.meta.source || f.includes(e.meta.source)));
+	let C = S.filter((e) => e.meta.source).map((e) => ({
+		...e,
+		value: r(e.context)
+	})).reduce((e, t) => ({
+		...e,
+		[t.meta.source]: t.value
+	}), {});
+	return Object.entries(x.current).filter(([e, t]) => t !== C[e]).length > 0 || Object.keys(C).length !== Object.keys(x.current).length ? x.current = C : (Object.keys(x.current).forEach((e) => {
+		delete x.current[e];
+	}), Object.entries(C).forEach(([e, t]) => {
+		x.current[e] = t;
+	})), x.current;
+}
+//#endregion
+export { s as default };

package/dist/dataSource/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DataSourceContext';
+export * from './hooks';

package/dist/dataSource/index.mjs

@@ -0,0 +1,2 @@
+import e from "./hooks/useDataSource.mjs";
+export { e as useDataSource };

package/dist/devTools/DevToolsContext.d.ts

@@ -0,0 +1,11 @@
+import { Log, ProviderCallback } from '../types';
+import { Dispatch, SetStateAction } from 'react';
+export type DevToolsContextValue = {
+    providers: Record<string, ProviderCallback>;
+    logs: Log[];
+    setLogs?: Dispatch<SetStateAction<Log[]>>;
+    clearLogs?: () => void;
+    getData?: (methodName: string, ...args: unknown[]) => Record<string, unknown> | undefined;
+};
+declare const DevToolsContext: import('react').Context<DevToolsContextValue>;
+export default DevToolsContext;

package/dist/devTools/DevToolsContext.mjs

@@ -0,0 +1,8 @@
+import { createContext as e } from "react";
+var t = e({
+	logs: [],
+	providers: {}
+});
+t.displayName = "DevToolsContext";
+//#endregion
+export { t as default };

package/dist/devTools/index.d.ts

@@ -0,0 +1,5 @@
+import { default as DevToolsContext } from './DevToolsContext';
+import { default as PlitziConsole } from './utils/PlitziConsole';
+export * from './utils/PlitziConsole';
+export * from './DevToolsContext';
+export { PlitziConsole, DevToolsContext };

package/dist/devTools/index.mjs

@@ -0,0 +1,3 @@
+import e from "./DevToolsContext.mjs";
+import t, { createStoreDevToolsLogger as n, pConsole as r } from "./utils/PlitziConsole.mjs";
+export { e as DevToolsContext, t as PlitziConsole, n as createStoreDevToolsLogger, r as pConsole };

package/dist/devTools/utils/PlitziConsole.d.ts

@@ -0,0 +1,39 @@
+import { Log, ProviderCallback } from '../../types/DevToolsTypes';
+import { StoreLogger } from '@plitzi/sdk-store';
+type CallbackInternal = (logType: Log['logType'], category: Log['category'], message: Log['message'], params: Record<string, unknown> | Log['params'], time?: Log['time']) => void;
+type CallbackAddProvider = (methodName: string, callback: ProviderCallback) => void;
+type CallbackRemoveProvider = (methodName: string) => void;
+declare class PlitziConsole {
+    #private;
+    callbackInternal?: CallbackInternal;
+    callbackAddProvider?: CallbackAddProvider;
+    callbackRemoveProvider?: CallbackRemoveProvider;
+    pendingLimit: number;
+    logsListenedLimit: number;
+    pendingLogs: Log[];
+    listening: boolean;
+    listeningCategory?: Log['category'];
+    logsListened: Log[];
+    listeningParams?: {
+        category: Log['category'];
+    };
+    constructor(callback?: CallbackInternal, pendingLimit?: number);
+    setCallback(callback?: CallbackInternal): void;
+    processPendingLogs(): void;
+    setCallbackAddProvider(callback?: CallbackAddProvider): void;
+    setCallbackRemoveProvider(callback?: CallbackRemoveProvider): void;
+    flush(hard?: boolean): void;
+    addProviderMethod(methodName: string, callback: ProviderCallback): void;
+    removeProviderMethod(methodName: string): void;
+    getTime(asString: true): string;
+    getTime(asString?: false): Date;
+    info(category: Log['category'], message: Log['message'], params: Log['params']): void;
+    warning(category: Log['category'], message: Log['message'], params: Log['params']): void;
+    danger(category: Log['category'], message: Log['message'], params: Log['params']): void;
+    success(category: Log['category'], message: Log['message'], params: Log['params']): void;
+    begin(category: Log['category']): void;
+    end(): void;
+}
+export declare const pConsole: PlitziConsole;
+export declare function createStoreDevToolsLogger<TState extends object>(storeName?: string): StoreLogger<TState>;
+export default PlitziConsole;

package/dist/devTools/utils/PlitziConsole.mjs

@@ -0,0 +1,97 @@
+import { formatDate as e } from "../../helpers/formatDate.mjs";
+import t from "@plitzi/sdk-store/helpers/getByPath";
+//#region src/devTools/utils/PlitziConsole.ts
+var n = class {
+	callbackInternal;
+	callbackAddProvider;
+	callbackRemoveProvider;
+	pendingLimit = 100;
+	logsListenedLimit = 1e3;
+	pendingLogs = [];
+	listening = !1;
+	listeningCategory;
+	logsListened = [];
+	listeningParams;
+	constructor(e, t = 100) {
+		this.callbackInternal = e, this.pendingLimit = t;
+	}
+	setCallback(e) {
+		this.callbackInternal = e;
+	}
+	processPendingLogs() {
+		if (this.pendingLogs.length && this.callbackInternal) {
+			for (let e of this.pendingLogs) this.callbackInternal(e.logType, e.category, e.message, e.params, e.time);
+			this.pendingLogs = [];
+		}
+	}
+	setCallbackAddProvider(e) {
+		this.callbackAddProvider = e;
+	}
+	setCallbackRemoveProvider(e) {
+		this.callbackRemoveProvider = e;
+	}
+	flush(e = !1) {
+		this.logsListened = [], e && (this.pendingLogs = []);
+	}
+	#e(e, t, n, r) {
+		let i = this.getTime(!0);
+		if (!this.callbackInternal) {
+			this.pendingLogs.push({
+				logType: e,
+				category: t,
+				message: n,
+				params: r,
+				time: i
+			}), this.pendingLogs.length > this.pendingLimit && this.pendingLogs.shift();
+			return;
+		}
+		this.listening ? this.logsListened.push({
+			logType: e,
+			category: t,
+			message: n,
+			params: r,
+			time: i
+		}) : this.callbackInternal(e, t, n, r, i), this.logsListened.length > this.logsListenedLimit && this.logsListened.shift();
+	}
+	addProviderMethod(e, t) {
+		this.callbackAddProvider?.(e, t);
+	}
+	removeProviderMethod(e) {
+		typeof this.callbackRemoveProvider == "function" && this.callbackRemoveProvider(e);
+	}
+	getTime(t = !1) {
+		let n = /* @__PURE__ */ new Date();
+		return t ? e(n, "HH:mm:ss.SSS") : n;
+	}
+	info(e, t, n) {
+		this.#e("info", e, t, n);
+	}
+	warning(e, t, n) {
+		this.#e("warning", e, t, n);
+	}
+	danger(e, t, n) {
+		this.#e("danger", e, t, n);
+	}
+	success(e, t, n) {
+		this.#e("success", e, t, n);
+	}
+	begin(e) {
+		this.listening = !0, this.listeningParams = { category: e };
+	}
+	end() {
+		this.listening = !1, this.listeningCategory && this.logsListened.length > 0 && this.callbackInternal?.("info", this.listeningCategory, `${this.logsListened.length} Log${this.logsListened.length === 1 ? "" : "s"}`, { logs: this.logsListened }), this.logsListened = [], this.listeningCategory = void 0;
+	}
+}, r = new n();
+function i(e = "store") {
+	return ({ path: n, prev: i, next: a }) => {
+		let o = n ? t(i, n) : i, s = n ? t(a, n) : a;
+		r.info("store", e, {
+			storeName: e,
+			path: n,
+			prev: o,
+			next: s
+		});
+	};
+}
+//#endregion
+export { i as createStoreDevToolsLogger, n as default, r as pConsole };

package/dist/elements/ComponentContext.d.ts

@@ -0,0 +1,3 @@
+import { ComponentContextValue } from '../types';
+declare const ComponentContext: import('react').Context<ComponentContextValue>;
+export default ComponentContext;

package/dist/elements/ComponentContext.mjs

@@ -0,0 +1,5 @@
+import { createContext as e } from "react";
+var t = e({});
+t.displayName = "ComponentContext";
+//#endregion
+export { t as default };

package/dist/elements/ElementContext.d.ts

@@ -0,0 +1,19 @@
+import { Element, ElementLayout } from '../types';
+import { CSSProperties } from 'react';
+export type ElementContextValue<T extends 'skipHOC' | 'full' = 'full'> = {
+    id: string;
+    rootId?: string;
+} & (T extends 'skipHOC' ? {
+    plitziJsxSkipHOC: true;
+} : {
+    plitziJsxSkipHOC?: boolean;
+    className?: string;
+    plitziElementLayout?: ElementLayout;
+    attributes: Element['attributes'];
+    definition: Element['definition'];
+    elementState: Record<string, unknown>;
+    style?: CSSProperties;
+    setElementState: <S extends Record<string, unknown> = Record<string, unknown>>(value?: S | ((prev: S) => S)) => boolean;
+});
+declare const ElementContext: import('react').Context<ElementContextValue<"full"> | ElementContextValue<"skipHOC">>;
+export default ElementContext;

package/dist/elements/ElementContext.mjs

@@ -0,0 +1,6 @@
+import { createContext as e } from "react";
+//#region src/elements/ElementContext.tsx
+var t = e(void 0);
+t.displayName = "ElementContext";
+//#endregion
+export { t as default };

package/dist/elements/hooks/useElement.d.ts

@@ -0,0 +1,3 @@
+import { ElementContextValue } from '../ElementContext';
+declare const useElement: <T extends "skipHOC" | "full" = "full">() => ElementContextValue<T>;
+export default useElement;

package/dist/elements/hooks/useElement.mjs

@@ -0,0 +1,10 @@
+import e from "../ElementContext.mjs";
+import { use as t } from "react";
+//#region src/elements/hooks/useElement.ts
+var n = () => {
+	let n = t(e);
+	if (n === void 0) throw Error("ElementContext value is undefined. Make sure you use the ElementContext before using the hook.");
+	return n;
+};
+//#endregion
+export { n as default };

package/dist/elements/index.d.ts

@@ -0,0 +1,7 @@
+import { default as ComponentContext } from './ComponentContext';
+import { default as ElementContext } from './ElementContext';
+import { default as useElement } from './hooks/useElement';
+export * from './ElementContext';
+export * from './ComponentContext';
+export * from './hooks/useElement';
+export { ComponentContext, ElementContext, useElement };

package/dist/elements/index.mjs

@@ -0,0 +1,4 @@
+import e from "./ComponentContext.mjs";
+import t from "./ElementContext.mjs";
+import n from "./hooks/useElement.mjs";
+export { e as ComponentContext, t as ElementContext, n as useElement };

package/dist/helpers/fetchManifest.d.ts

@@ -0,0 +1,2 @@
+declare const fetchManifest: <T extends object>(manifestUrl: string) => Promise<T | undefined>;
+export default fetchManifest;

package/dist/helpers/fetchManifest.mjs

@@ -0,0 +1,14 @@
+//#region src/helpers/fetchManifest.ts
+var e = async (e) => {
+	let t;
+	try {
+		return t = await (await fetch(e, {
+			method: "GET",
+			headers: { "Content-Type": "application/json" }
+		})).json(), t;
+	} catch {
+		return t;
+	}
+};
+//#endregion
+export { e as default };

package/dist/helpers/formatDate.d.ts

@@ -0,0 +1,56 @@
+import { FormatDistanceToNowOptions } from 'date-fns';
+export type SupportedLocale = 'en' | 'es' | 'pt';
+/**
+ * Converts a date input to a valid JavaScript Date object.
+ *
+ * Supports multiple input formats:
+ *
+ * - Date: returned as-is
+ * - Number: interpreted as timestamp
+ *
+ *   - < 1e12 → treated as seconds and converted to milliseconds
+ *   - > = 1e12 → treated as milliseconds
+ * - String: parsed as ISO 8601 date string
+ *
+ * @param {Date | number | string} d - The date input to normalize
+ * @returns {Date} A valid JavaScript Date object
+ */
+export declare const parseDate: (date: string | number | Date) => Date;
+/**
+ * Formats a date to a readable string, with locale support.
+ *
+ * @param date - Date as timestamp (ms), timestamp in seconds, or ISO string
+ * @param formatStr - Date-fns format string (default 'dd MMMM, yyyy')
+ * @param locale - 'en' | 'es' | 'pt' (default 'en')
+ */
+export declare function formatDate(date?: string | number | Date, formatStr?: string, locale?: SupportedLocale): string;
+export declare function formatDateUTC(date?: string | number | Date, formatStr?: string, locale?: SupportedLocale): string;
+/** Formats a UTC timestamp/string to local timezone */
+export declare function formatUTCToLocal(date?: string | number | Date, formatStr?: string, locale?: SupportedLocale): string;
+/**
+ * Returns the difference between two dates in milliseconds
+ *
+ * @param start - Date, timestamp (ms or s) or ISO string
+ * @param end - Date, timestamp (ms or s) or ISO string
+ */
+export declare function getDurationMs(start: string | number | Date, end: string | number | Date): number;
+/**
+ * Returns a human-readable "time ago" string.
+ *
+ * Supports:
+ *
+ * - Date objects
+ * - Timestamps (ms or seconds)
+ * - ISO strings
+ *
+ * Examples: formatFromNow('2024-01-01') → "2 months ago" formatFromNow(1700000000, 'es') → "hace 3 meses"
+ *
+ * @param date - Date, ISO string, or timestamp
+ * @param locale - 'en' | 'es' | 'pt' (default 'en')
+ * @returns {string} A human-friendly "from now" string
+ */
+export declare function formatFromNow(date?: string | number | Date, locale?: SupportedLocale, options?: FormatDistanceToNowOptions): string;
+export declare function isValidFormat(formatStr: string): boolean;
+export declare const toUnixSeconds: (input: string | number | Date) => string;
+/** Strictly validates whether a string matches a given date-fns format. */
+export declare function isDate(value: string, formatStr: string): boolean;

package/dist/helpers/formatDate.mjs

@@ -0,0 +1,54 @@
+import { differenceInMilliseconds as e, format as t, formatDistanceToNow as n, getTime as r, isValid as i, parse as a, parseISO as o } from "date-fns";
+import { enUS as s, es as c, pt as l } from "date-fns/locale";
+import { toZonedTime as u } from "date-fns-tz";
+//#region src/helpers/formatDate.ts
+var d = {
+	en: s,
+	es: c,
+	pt: l
+}, f = (e) => {
+	let t;
+	return t = typeof e == "number" ? e < 0xe8d4a51000 ? /* @__PURE__ */ new Date(e * 1e3) : new Date(e) : typeof e == "string" ? o(e) : e, t;
+};
+function p(e, n = "dd MMMM, yyyy", r = "en") {
+	return e ? t(f(e), n, { locale: d[r] }) : "";
+}
+function m(e, n = "dd MMMM, yyyy", r = "en") {
+	return e ? t(u(f(e), "UTC"), n, { locale: d[r] }) : "";
+}
+function h(e, n = "dd MMMM, yyyy HH:mm", r = "en") {
+	if (!e) return "";
+	let i = f(e), a = Intl.DateTimeFormat().resolvedOptions().timeZone;
+	return t(u(i, a), n, { locale: d[r] });
+}
+function g(t, n) {
+	let r = f(t);
+	return e(f(n), r);
+}
+function _(e, t = "en", r) {
+	if (!e) return "";
+	let i = f(e);
+	return isNaN(i.getTime()) ? "" : n(i, {
+		...r,
+		locale: d[t]
+	});
+}
+function v(e) {
+	try {
+		return t(/* @__PURE__ */ new Date(), e), !0;
+	} catch {
+		return !1;
+	}
+}
+var y = (e) => Math.floor(r(f(e)) / 1e3).toString();
+function b(e, n) {
+	if (typeof e != "string") return !1;
+	try {
+		let r = a(e, n, /* @__PURE__ */ new Date());
+		return i(r) ? t(r, n) === e : !1;
+	} catch {
+		return !1;
+	}
+}
+//#endregion
+export { p as formatDate, m as formatDateUTC, _ as formatFromNow, h as formatUTCToLocal, g as getDurationMs, b as isDate, v as isValidFormat, f as parseDate, y as toUnixSeconds };

package/dist/helpers/generateFacade.d.ts

@@ -0,0 +1,2 @@
+declare const generateFacade: (modules: Record<string, unknown>, windowKey?: string) => void;
+export default generateFacade;

package/dist/helpers/generateFacade.mjs

@@ -0,0 +1,35 @@
+import { omit as e } from "@plitzi/plitzi-ui/helpers";
+//#region src/helpers/generateFacade.tsx
+var t = (e) => e.replace(/^@/, "").replace(/[-/]/g, " ").replace(/\b\w/g, (e) => e.toUpperCase()).replace(/\s+/g, ""), n = (e, t = "PlitziFacade") => {
+	let n = typeof window < "u" ? Object.keys(window[t]?.[e] ?? {}) : [];
+	return n.length === 0 ? "" : `export default window.${t}.${e};${n.filter((e) => e !== "default").map((n) => `export const ${n} = window.${t}.${e}.${n};`).join("")}`;
+}, r = (e) => URL.createObjectURL(new Blob([e], { type: "application/javascript" })), i = () => {
+	let e = {};
+	return typeof document > "u" || document.querySelectorAll("script[type=\"importmap\"]").forEach((t) => {
+		if (t.textContent) try {
+			let n = JSON.parse(t.textContent);
+			n.imports && Object.entries(n.imports).forEach(([t, n]) => {
+				e[t] && console.warn(`Duplicated import detected: "${t}"`), e[t] = n;
+			});
+		} catch (e) {
+			console.error("Invalid importmap JSON", e);
+		}
+	}), e;
+}, a = (e, i = "PlitziFacade") => JSON.stringify({ imports: Object.keys(e).map((e) => ({
+	key: e,
+	bob: r(n(t(e), i))
+})).reduce((e, t) => ({
+	...e,
+	[t.key]: t.bob
+}), {}) }), o = (n, r = "PlitziFacade") => {
+	if (typeof document > "u" || typeof window > "u") return;
+	let o = i(), s = e(n, Object.keys(o));
+	if (Object.keys(s).length === 0) return;
+	window[r] = Object.fromEntries(Object.entries(s).map(([e, n]) => [t(e), n]));
+	let c = a(s, r);
+	if (!c) return;
+	let l = document.createElement("script");
+	l.type = "importmap", l.textContent = c, document.head.appendChild(l);
+};
+//#endregion
+export { o as default };

package/dist/helpers/index.d.ts

@@ -0,0 +1,12 @@
+import { default as fetchManifest } from './fetchManifest';
+import { default as generateFacade } from './generateFacade';
+import { default as syntaxHighlight } from './syntaxHighlight';
+export * from './fetchManifest';
+export * from './formatDate';
+export * from './generateFacade';
+export * from './syntaxHighlight';
+export * from './twigWrapper';
+export * from './utils';
+export * from './security';
+export * from './stripTypename';
+export { fetchManifest, generateFacade, syntaxHighlight };