@explita/formly 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { Form } from "./providers/form";
+export * from "./components";
+export * from "./hooks/use-form";
+export * from "./hooks/use-field";
+export * from "./hooks/use-form-context";
+export * from "./hooks/use-form-by-id";
+export * from "./utils";
+export type { HandlerContext, FormShape, FormInstance } from "./types/utils";
+export type * from "./types/array";

package/dist/index.js

@@ -0,0 +1,25 @@
+"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.Form = void 0;
+var form_1 = require("./providers/form");
+Object.defineProperty(exports, "Form", { enumerable: true, get: function () { return form_1.Form; } });
+__exportStar(require("./components"), exports);
+__exportStar(require("./hooks/use-form"), exports);
+__exportStar(require("./hooks/use-field"), exports);
+__exportStar(require("./hooks/use-form-context"), exports);
+__exportStar(require("./hooks/use-form-by-id"), exports);
+__exportStar(require("./utils"), exports);

package/dist/lib/array-helpers.d.ts

@@ -0,0 +1,6 @@
+import { ArrayHelperProps, ArrayHelpers, HandlerArrayHelpers } from "../types/array";
+import { Path } from "../types/path";
+export declare function formArrayHelper<T = any>(props: ArrayHelperProps<T>): ArrayHelpers<T>;
+export declare function handlerArrayHelpers<T>(path: Path<T>, data: T): HandlerArrayHelpers<T>;
+export declare function getArrayKeys(path: string, values: any): number[];
+export declare function extraxtArrayPrefixies(path: string, index: number, deps?: string[]): string[];

package/dist/lib/array-helpers.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formArrayHelper = formArrayHelper;
+exports.handlerArrayHelpers = handlerArrayHelpers;
+exports.getArrayKeys = getArrayKeys;
+exports.extraxtArrayPrefixies = extraxtArrayPrefixies;
+const deep_path_1 = require("./deep-path");
+const utils_1 = require("./utils");
+function formArrayHelper(props) {
+    const { path, formValues, setValues, compute, computed, getCurrentArrayValue, } = props;
+    function get() {
+        return getCurrentArrayValue() || [];
+    }
+    let working = [...get()];
+    function set(arr) {
+        const newFlat = { ...formValues };
+        Object.keys(formValues || {}).forEach((key) => {
+            if (key.startsWith(path)) {
+                delete newFlat[key];
+            }
+        });
+        // set new array keys
+        arr.forEach((v, i) => {
+            //@ts-ignore
+            newFlat[`${path}.${i}`] = v;
+        });
+        setValues(newFlat, { overwrite: true });
+    }
+    function remove(index) {
+        removeArrayItem(formValues, setValues, path, index);
+    }
+    function clear() {
+        clearArray(formValues, setValues, path);
+    }
+    const api = {
+        get: () => structuredClone(get()),
+        get value() {
+            return structuredClone(get());
+        },
+        get length() {
+            return get().length;
+        },
+        filter(fn) {
+            const filtered = get().filter(fn);
+            working = filtered;
+            set(filtered);
+            return api;
+        },
+        map(fn) {
+            const mapped = get().map(fn);
+            working = mapped;
+            set(mapped);
+            return api;
+        },
+        replaceAll: (value) => {
+            set(value);
+            working = [...value];
+            return api;
+        },
+        push(items) {
+            const newValues = Array.isArray(items) ? items : [items];
+            const oldValues = get();
+            const combined = [...oldValues, ...newValues];
+            working = combined;
+            set(combined);
+            const startIndex = oldValues.length;
+            //@ts-ignore
+            generateComputedKeys(path, startIndex, newValues, compute, computed);
+            return api;
+        },
+        insert: (index, item) => {
+            working.splice(index, 0, item);
+            set(working);
+            return api;
+        },
+        insertFirst: (item) => {
+            working.unshift(item);
+            set(working);
+            return api;
+        },
+        updateAt: (index, item) => {
+            const oldValues = get();
+            working = [...oldValues];
+            working[index] = item;
+            set(working);
+            return api;
+        },
+        swap: (a, b) => {
+            [working[a], working[b]] = [working[b], working[a]];
+            set(working);
+            return api;
+        },
+        move: (from, to) => {
+            const [item] = working.splice(from, 1);
+            working.splice(to, 0, item);
+            set(working);
+            return api;
+        },
+        moveUp(index) {
+            if (index <= 0)
+                return api;
+            return api.move(index, index - 1);
+        },
+        moveDown(index) {
+            const arr = get();
+            if (index >= arr.length - 1)
+                return api;
+            return api.move(index, index + 1);
+        },
+        compact() {
+            const filtered = get().filter(Boolean);
+            working = filtered;
+            set(filtered);
+            return api;
+        },
+        replaceWhere(fn, newItem) {
+            const arr = get().map((item) => (fn(item) ? newItem : item));
+            working = arr;
+            set(arr);
+            return api;
+        },
+        merge(fn) {
+            const oldValues = get();
+            const newValues = fn(oldValues);
+            working = newValues;
+            set(newValues);
+            const startIndex = oldValues.length;
+            //@ts-ignore
+            generateComputedKeys(path, startIndex, newValues, compute, computed);
+            return api;
+        },
+        sort(fn) {
+            const sorted = [...get()].sort(fn);
+            working = sorted;
+            set(sorted);
+            return api;
+        },
+        remove,
+        removeIf(fn) {
+            const filtered = get().filter((item, index) => !fn(item, index));
+            working = filtered;
+            set(filtered);
+            return api;
+        },
+        clear,
+        toObject() {
+            return get().reduce((acc, item, idx) => {
+                acc[idx] = item;
+                return acc;
+            }, {});
+        },
+        some: (fn) => get().some(fn),
+        every: (fn) => get().every(fn),
+        findIndex: (fn) => get().findIndex(fn),
+        isFirst: (index) => index === 0,
+        isLast: (index) => index === get().length - 1,
+        first: () => get()[0],
+        last: () => get()[get().length - 1],
+        // done() {
+        //   set(working);
+        // },
+    };
+    return api;
+}
+function generateComputedKeys(path, startIndex, newValues, compute, computed) {
+    if (!computed)
+        return;
+    for (const key in computed) {
+        if (key.startsWith(path + "*")) {
+            const fieldName = key.split("*")[1];
+            //@ts-ignore
+            const template = computed[key];
+            // compute for each new item
+            newValues.forEach((_, i) => {
+                const index = startIndex + i;
+                const computedKey = `${path}.${index}.${fieldName}`;
+                const fieldDeps = extraxtArrayPrefixies(path, index, template.deps);
+                compute(computedKey, 
+                // @ts-ignore
+                fieldDeps, (vals) => template.fn(vals, index));
+            });
+        }
+    }
+}
+function handlerArrayHelpers(path, data) {
+    const api = {
+        get: () => { var _a; return (_a = (0, deep_path_1.getDeepValue)(data, path)) !== null && _a !== void 0 ? _a : []; },
+        get value() {
+            var _a;
+            return (_a = (0, deep_path_1.getDeepValue)(data, path)) !== null && _a !== void 0 ? _a : [];
+        },
+        snapshot: () => structuredClone(data),
+        filter: (fn) => {
+            var _a;
+            const arr = (_a = (0, deep_path_1.getDeepValue)(data, path)) !== null && _a !== void 0 ? _a : [];
+            const filtered = arr.filter(fn);
+            (0, deep_path_1.setValueByPath)(data, path, filtered);
+            return api;
+        },
+        removeIf: (fn) => {
+            var _a;
+            const arr = (_a = (0, deep_path_1.getDeepValue)(data, path)) !== null && _a !== void 0 ? _a : [];
+            const filtered = arr.filter((item, index) => !fn(item, index));
+            (0, deep_path_1.setValueByPath)(data, path, filtered);
+            return api;
+        },
+        map: (fn) => {
+            var _a;
+            const arr = (_a = (0, deep_path_1.getDeepValue)(data, path)) !== null && _a !== void 0 ? _a : [];
+            const mapped = arr.map(fn);
+            (0, deep_path_1.setValueByPath)(data, path, mapped);
+            return api;
+        },
+    };
+    return api;
+}
+function removeArrayItem(formValues, setValues, path, index) {
+    const prefix = `${path}.`;
+    const flat = { ...formValues };
+    const keys = Object.keys(flat || {}).filter((k) => k.startsWith(prefix));
+    // Sort descending to avoid index shift issues
+    keys.sort((a, b) => {
+        const ai = parseInt(a.slice(prefix.length).split(".")[0], 10);
+        const bi = parseInt(b.slice(prefix.length).split(".")[0], 10);
+        return bi - ai;
+    });
+    const updated = {};
+    for (const key in flat) {
+        if (!key.startsWith(prefix)) {
+            updated[key] = flat[key];
+        }
+    }
+    for (const key of keys) {
+        const rest = key.slice(prefix.length);
+        const [arrayIndexStr] = rest.split(".");
+        const currentIndex = parseInt(arrayIndexStr, 10);
+        if (Number.isNaN(currentIndex))
+            continue;
+        if (currentIndex === index)
+            continue;
+        const newIndex = currentIndex > index ? currentIndex - 1 : currentIndex;
+        const newKey = key.replace(new RegExp(`^${prefix}${currentIndex}`), `${prefix}${newIndex}`);
+        updated[newKey] = flat[key];
+    }
+    const nested = (0, utils_1.nestFormValues)(updated);
+    // Ensure array still exists
+    if (!Array.isArray((0, deep_path_1.getDeepValue)(nested, path))) {
+        (0, deep_path_1.setDeepValue)(nested, path, []);
+    }
+    setValues(nested, { overwrite: true });
+}
+function clearArray(formValues, setValues, path) {
+    const updated = (0, utils_1.nestFormValues)(formValues);
+    (0, deep_path_1.setDeepValue)(updated, path, []);
+    setValues({ ...updated }, { overwrite: true });
+}
+function getArrayKeys(path, values) {
+    const indexes = new Set();
+    for (const key of Object.keys(values)) {
+        if (key.startsWith(path + ".")) {
+            const match = key.match(new RegExp(`^${path}\\.(\\d+)\\.`));
+            if (match)
+                indexes.add(Number(match[1]));
+        }
+    }
+    return Array.from(indexes).sort((a, b) => a - b);
+}
+function extraxtArrayPrefixies(path, index, deps) {
+    return ((deps === null || deps === void 0 ? void 0 : deps.map((dep) => {
+        // If dep starts with the same array path, replace its first numeric index
+        const arrayPrefix = path + ".";
+        if (dep.startsWith(arrayPrefix)) {
+            // extract the remaining path after the first dot
+            const rest = dep
+                .slice(arrayPrefix.length)
+                .replace(/^\d+/, index.toString());
+            return `${path}.${rest}`;
+        }
+        return dep; // global deps stay as-is
+    })) || []);
+}

package/dist/lib/css.d.ts

@@ -0,0 +1 @@
+export declare const css = ".explita-form .form-label {\n  display: flex;\n  align-items: center;\n  gap: 0.5rem; /* gap-2 */\n  font-size: 0.875rem; /* text-sm */\n  line-height: 1.25rem; /* leading-none */\n  font-weight: 500; /* font-medium */\n  user-select: none; /* select-none */\n}\n\n/* Disabled group */\n.explita-form .group[data-disabled=\"true\"] .form-label {\n  pointer-events: none;\n  opacity: 0.5;\n}\n\n/* Disabled peer */\n.explita-form .peer:disabled ~ .form-label {\n  cursor: not-allowed;\n  opacity: 0.5;\n}\n\n/* Required field */\n.explita-form .form-label[data-required=\"true\"]::after {\n  content: \"*\";\n  color: #ef4444; /* Tailwind red-500 */\n  font-size: 1rem; /* text-base */\n  margin-left: -0.25rem; /* ml-1 */\n}\n\n/* Error state */\n.explita-form .form-label[data-error=\"true\"] {\n  color: #ef4444; /* red-500 */\n}\n\n/* Input error state */\n.explita-form [data-input-error=\"true\"] {\n  border-color: #ef4444 !important; /* red-500 */\n  // outline: none !important;\n  outline-color: #ef4444;\n}\n";

package/dist/lib/css.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.css = void 0;
+exports.css = `.explita-form .form-label {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem; /* gap-2 */
+  font-size: 0.875rem; /* text-sm */
+  line-height: 1.25rem; /* leading-none */
+  font-weight: 500; /* font-medium */
+  user-select: none; /* select-none */
+}
+
+/* Disabled group */
+.explita-form .group[data-disabled="true"] .form-label {
+  pointer-events: none;
+  opacity: 0.5;
+}
+
+/* Disabled peer */
+.explita-form .peer:disabled ~ .form-label {
+  cursor: not-allowed;
+  opacity: 0.5;
+}
+
+/* Required field */
+.explita-form .form-label[data-required="true"]::after {
+  content: "*";
+  color: #ef4444; /* Tailwind red-500 */
+  font-size: 1rem; /* text-base */
+  margin-left: -0.25rem; /* ml-1 */
+}
+
+/* Error state */
+.explita-form .form-label[data-error="true"] {
+  color: #ef4444; /* red-500 */
+}
+
+/* Input error state */
+.explita-form [data-input-error="true"] {
+  border-color: #ef4444 !important; /* red-500 */
+  // outline: none !important;
+  outline-color: #ef4444;
+}
+`;

package/dist/lib/debounce.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Creates a debounced function that delays invoking the provided function until
+ * after `delay` milliseconds have passed since the last time the debounced
+ * function was called. The debounced function returns a function that can be
+ * used to cancel the pending call to the underlying function.
+ *
+ * @param fn The function to debounce.
+ * @param delay The number of milliseconds to delay calling the function.
+ * @returns A debounced function with an extra `cancel` method to cancel the pending call.
+ */
+export declare function debounce<T extends (...args: any[]) => void>(fn: T, delay: number): T & {
+    cancel: () => void;
+};

package/dist/lib/debounce.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = debounce;
+/**
+ * Creates a debounced function that delays invoking the provided function until
+ * after `delay` milliseconds have passed since the last time the debounced
+ * function was called. The debounced function returns a function that can be
+ * used to cancel the pending call to the underlying function.
+ *
+ * @param fn The function to debounce.
+ * @param delay The number of milliseconds to delay calling the function.
+ * @returns A debounced function with an extra `cancel` method to cancel the pending call.
+ */
+function debounce(fn, delay) {
+    let timeout;
+    function debounced(...args) {
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(() => fn.apply(this, args), delay);
+    }
+    debounced.cancel = () => {
+        if (timeout) {
+            clearTimeout(timeout);
+            timeout = null;
+        }
+    };
+    return debounced;
+}

package/dist/lib/deep-path.d.ts

@@ -0,0 +1,4 @@
+export declare function getValueByPath<T extends any>(obj: T, path: string): T;
+export declare function setValueByPath<T extends any>(obj: T, path: string, value: any): void;
+export declare function getDeepValue(obj: any, path: string): any;
+export declare function setDeepValue(obj: any, path: string, value: any): void;

package/dist/lib/deep-path.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValueByPath = getValueByPath;
+exports.setValueByPath = setValueByPath;
+exports.getDeepValue = getDeepValue;
+exports.setDeepValue = setDeepValue;
+const utils_1 = require("./utils");
+function getValueByPath(obj, path) {
+    return (path === null || path === void 0 ? void 0 : path.split(/[\.\[\]]+/).filter(Boolean).reduce((acc, key) => (acc ? acc[key] : undefined), obj));
+}
+function setValueByPath(obj, path, value) {
+    const keys = path.split(/[\.\[\]]+/).filter(Boolean);
+    let current = obj;
+    keys.forEach((key, idx) => {
+        var _a;
+        if (idx === keys.length - 1) {
+            //@ts-ignore
+            current[key] = value;
+        }
+        else {
+            //@ts-ignore
+            current[key] = (_a = current[key]) !== null && _a !== void 0 ? _a : {};
+            //@ts-ignore
+            current = current[key];
+        }
+    });
+}
+function getDeepValue(obj, path) {
+    if (!obj || !path)
+        return undefined;
+    const parts = path.split(".");
+    let current = (0, utils_1.nestFormValues)(obj);
+    for (const part of parts) {
+        if (current == null)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function setDeepValue(obj, path, value) {
+    if (!obj || !path)
+        return;
+    const parts = path.split(".");
+    let current = obj;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const isLast = i === parts.length - 1;
+        if (isLast) {
+            current[part] = value;
+        }
+        else {
+            if (current[part] == null || typeof current[part] !== "object") {
+                // Determine if the next part looks like an array index
+                const nextIsIndex = /^\d+$/.test(parts[i + 1]);
+                current[part] = nextIsIndex ? [] : {};
+            }
+            current = current[part];
+        }
+    }
+}

package/dist/lib/drafts-helpter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Writes a draft to local storage immediately.
+ * This function takes a draft key and a draft value as arguments.
+ * It will update the local storage with the new draft value.
+ *
+ * Note: This function is not debounced and will write to local storage immediately, and don't use it for performance critical code.
+ */
+export declare function writeDraftImmediate<T extends unknown>(draftKey: string, data: T): void;
+/**
+ * Writes a draft to local storage.
+ * This function is debounced to prevent excessive writes to local storage.
+ * The function takes a draft key and a draft value as arguments.
+ * It will update the local storage with the new draft value.
+ *
+ * Note: This function is debounced and will write to local storage after a delay of 200ms, good for performance.
+ */
+export declare const writeDraft: typeof writeDraftImmediate & {
+    cancel: () => void;
+};
+/**
+ * Reads a draft from local storage.
+ * This function takes a draft key as an argument and returns the corresponding * draft value.
+ * If the draft key does not exist in local storage, the function will return
+ * undefined.
+ */
+export declare function readDraft(draftKey: string): unknown;
+/**
+ * Deletes a draft from local storage.
+ * This function takes a draft key as an argument and removes the corresponding draft from local storage.
+ */
+export declare function deleteDraft(draftKey: string): void;

package/dist/lib/drafts-helpter.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeDraft = void 0;
+exports.writeDraftImmediate = writeDraftImmediate;
+exports.readDraft = readDraft;
+exports.deleteDraft = deleteDraft;
+const debounce_1 = require("./debounce");
+function getDrafts() {
+    const stored = localStorage.getItem("drafts");
+    if (!stored)
+        return {};
+    try {
+        return JSON.parse(stored) || {};
+    }
+    catch {
+        localStorage.removeItem("drafts"); // corrupted data
+        return {};
+    }
+}
+function setDrafts(drafts) {
+    if (Object.keys(drafts).length === 0) {
+        localStorage.removeItem("drafts");
+    }
+    else {
+        localStorage.setItem("drafts", JSON.stringify(drafts));
+    }
+}
+/**
+ * Writes a draft to local storage immediately.
+ * This function takes a draft key and a draft value as arguments.
+ * It will update the local storage with the new draft value.
+ *
+ * Note: This function is not debounced and will write to local storage immediately, and don't use it for performance critical code.
+ */
+function writeDraftImmediate(draftKey, data) {
+    const drafts = getDrafts();
+    const newDrafts = { ...drafts, [draftKey]: data };
+    setDrafts(newDrafts);
+}
+/**
+ * Writes a draft to local storage.
+ * This function is debounced to prevent excessive writes to local storage.
+ * The function takes a draft key and a draft value as arguments.
+ * It will update the local storage with the new draft value.
+ *
+ * Note: This function is debounced and will write to local storage after a delay of 200ms, good for performance.
+ */
+exports.writeDraft = (0, debounce_1.debounce)(writeDraftImmediate, 200);
+/**
+ * Reads a draft from local storage.
+ * This function takes a draft key as an argument and returns the corresponding * draft value.
+ * If the draft key does not exist in local storage, the function will return
+ * undefined.
+ */
+function readDraft(draftKey) {
+    const drafts = getDrafts();
+    return drafts[draftKey];
+}
+/**
+ * Deletes a draft from local storage.
+ * This function takes a draft key as an argument and removes the corresponding draft from local storage.
+ */
+function deleteDraft(draftKey) {
+    const drafts = getDrafts();
+    const newDrafts = Object.fromEntries(Object.entries(drafts).filter(([key]) => key !== draftKey));
+    setDrafts(newDrafts);
+}

package/dist/lib/form-registry.d.ts

@@ -0,0 +1,9 @@
+import { FormInstance } from "../types/utils";
+declare class FormRegistry {
+    private forms;
+    add<T>(id: string, form: FormInstance<T>): () => void;
+    get<T extends FormInstance<any>>(id: string): T;
+    delete(id: string): void;
+}
+export declare const registry: FormRegistry;
+export {};

package/dist/lib/form-registry.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registry = void 0;
+class FormRegistry {
+    constructor() {
+        this.forms = new Map();
+    }
+    add(id, form) {
+        this.forms.set(id, form);
+        return () => {
+            this.forms.delete(id);
+        };
+    }
+    get(id) {
+        const form = this.forms.get(id);
+        if (!form)
+            throw new Error(`Form with ID "${id}" not found`);
+        return form;
+    }
+    delete(id) {
+        this.forms.delete(id);
+    }
+}
+exports.registry = new FormRegistry();

package/dist/lib/group-helpers.d.ts

@@ -0,0 +1,9 @@
+import { GroupHelpersProps } from "../types/group";
+export declare function groupHelpers<T>(props: GroupHelpersProps<T>): {
+    get: () => {};
+    set: (vals: any, options?: {
+        overwrite?: boolean;
+    }) => void;
+    reset: (to?: any) => void;
+    validate: () => Promise<void>;
+};

package/dist/lib/group-helpers.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupHelpers = groupHelpers;
+const deep_path_1 = require("./deep-path");
+function groupHelpers(props) {
+    const { path, formValues, defaultValues, setValues, getCurrentValue, validatePartial, } = props;
+    const getGroupValues = () => { var _a; return (_a = getCurrentValue()) !== null && _a !== void 0 ? _a : {}; };
+    const setGroupValues = (vals, options) => {
+        const current = getGroupValues();
+        const merged = (options === null || options === void 0 ? void 0 : options.overwrite) ? vals : { ...current, ...vals };
+        (0, deep_path_1.setDeepValue)(formValues, path, merged);
+        setValues(formValues, { overwrite: true });
+    };
+    const reset = (to) => {
+        var _a;
+        const defaultGroup = (_a = to !== null && to !== void 0 ? to : (0, deep_path_1.getDeepValue)(defaultValues || {}, path)) !== null && _a !== void 0 ? _a : {};
+        setGroupValues(defaultGroup);
+    };
+    const validate = async () => {
+        const groupValues = getGroupValues();
+        await validatePartial({ [path]: groupValues });
+    };
+    return {
+        get: getGroupValues,
+        set: setGroupValues,
+        reset,
+        validate,
+    };
+}

package/dist/lib/pub-sub.d.ts

@@ -0,0 +1,13 @@
+import { ChannelEvent } from "../types/pub-sub";
+export type Callback<T> = (payload: T) => void;
+export declare function createChannel<T = any>(): {
+    emit<T_1>(payload: T_1): void;
+    subscribe(cb: Callback<T>): () => void;
+    clear(): void;
+};
+export declare function createFormBus<T>(): {
+    channel: {
+        (name: ChannelEvent<T>): ReturnType<typeof createChannel<T>>;
+        clearAll(): void;
+    };
+};