@neeloong/form 0.1.0

package/index.d.mts

@@ -0,0 +1,312 @@
+/*!
+* @neeloong/form v0.1.0
+* (c) 2024-2025 Fierflame
+* @license Apache-2.0
+*/
+
+export { Signal } from 'signal-polyfill';
+
+type VerifyError = any;
+type Component = {
+    tag: string | ((ctx: any) => Element);
+    is?: string | undefined;
+    attrs?: Record<string, Component.Attr> | undefined;
+    events?: Record<string, Component.Event> | undefined;
+};
+declare namespace Component {
+    type Attr = {
+        type: string;
+        /**
+         * // TODO: 可否计算，可否关联
+         */
+        isProp?: boolean | undefined;
+        bind?: [event: string, set: ($event: any, global: any) => any, (boolean | undefined)?] | "hidden" | "clearable" | "readonly" | "disabled" | "required" | undefined;
+        default?: any;
+        immutable?: boolean | undefined;
+    };
+    type Handler = {
+        set: (name: string, value: any) => void;
+        addEvent: (event: string, listener: ($event: any, global: any) => any) => void;
+        destroy: () => void;
+        tag: any;
+        init: () => void;
+    };
+    type Context = {
+        props?: Set<string> | null | undefined;
+        events: [string, ($event: any) => void, AddEventListenerOptions][];
+        tagAttrs: Record<string, any>;
+        watchAttr: (name: any, fn: (value: any, old: any, name: string) => void) => () => void;
+        destroyed: boolean;
+        init: boolean;
+        listen: <K extends keyof Component.Context.Events>(event: K, listener: (...p: Component.Context.Events[K]) => void) => () => void;
+    };
+    namespace Context {
+        type Events = {
+            init: [value: {
+                events: [string, ($event: any) => void, AddEventListenerOptions][];
+            }];
+            destroy: [];
+        };
+    }
+    type Event = {
+        /**
+         * 过滤器
+         */
+        filters: Record<string, (($event: any, param: string[], env: any) => boolean | null | void) | string>;
+    };
+}
+type ComponentGetter = (path: string[], next?: ((path: string[]) => Component | null) | undefined) => Component | null;
+type Schema = Record<string, Schema.Field>;
+declare namespace Schema {
+    type Field = (Schema.Object | Schema.Type) & Schema.Attr;
+    type Value = {
+        label: string;
+        value: string | number;
+    };
+    namespace Value {
+        type Group = {
+            label: string;
+            value?: string | number | undefined;
+            children: (Schema.Value.Group | Schema.Value | string | number)[];
+        };
+    }
+    type Object = {
+        type?: null | undefined;
+        props?: Record<string, Schema.Field> | undefined;
+        array?: boolean | undefined;
+        meta?: any;
+    };
+    type Type = {
+        type: string;
+        props?: null | undefined;
+        array?: boolean | undefined;
+        meta?: any;
+    };
+    type Attr = {
+        immutable?: boolean | undefined;
+        creatable?: boolean | undefined;
+        hidden?: boolean | ((store: Store) => boolean) | null | undefined;
+        clearable?: boolean | ((store: Store) => boolean) | null | undefined;
+        required?: boolean | ((store: Store) => boolean) | null | undefined;
+        disabled?: boolean | ((store: Store) => boolean) | null | undefined;
+        readonly?: boolean | ((store: Store) => boolean) | null | undefined;
+    };
+}
+
+/** @import { Schema } from '../types.mjs' */
+/**
+ * @template [T=any]
+ */
+declare class Store<T = any> {
+    /**
+     * @param {Schema} schema
+     * @param {object} [options]
+     * @param {boolean} [options.new]
+     */
+    static create(schema: Schema, options?: {
+        new?: boolean | undefined;
+    }): ObjectStore;
+    /**
+     * @param {Schema.Field} schema
+     * @param {object} options
+     * @param {*} [options.parent]
+     * @param {*} [options.state]
+     * @param {number | string | null} [options.index]
+     * @param {number} [options.length]
+     * @param {boolean} [options.null]
+     * @param {boolean} [options.new]
+     * @param {boolean} [options.hidden]
+     * @param {boolean} [options.clearable]
+     * @param {boolean} [options.required]
+     * @param {boolean} [options.readonly]
+     * @param {boolean} [options.disabled]
+     * @param {((value: any) => any)?} [options.setValue]
+     * @param {((value: any) => any)?} [options.setState]
+     * @param {((value: any, state: any) => [value: any, state: any])?} [options.convert]
+     * @param {((value: T?, index: any) => void)?} [options.onUpdate]
+     * @param {((value: T?, index: any) => void)?} [options.onUpdateState]
+     */
+    constructor(schema: Schema.Field, { null: isNull, state, setValue, setState, convert, onUpdate, onUpdateState, index, length, new: isNew, parent: parentNode, hidden, clearable, required, disabled, readonly, }: {
+        parent?: any;
+        state?: any;
+        index?: string | number | null | undefined;
+        length?: number | undefined;
+        null?: boolean | undefined;
+        new?: boolean | undefined;
+        hidden?: boolean | undefined;
+        clearable?: boolean | undefined;
+        required?: boolean | undefined;
+        readonly?: boolean | undefined;
+        disabled?: boolean | undefined;
+        setValue?: ((value: any) => any) | null | undefined;
+        setState?: ((value: any) => any) | null | undefined;
+        convert?: ((value: any, state: any) => [value: any, state: any]) | null | undefined;
+        onUpdate?: ((value: T | null, index: any) => void) | null | undefined;
+        onUpdateState?: ((value: T | null, index: any) => void) | null | undefined;
+    });
+    get null(): boolean;
+    schema: Schema.Field;
+    get parent(): Store<any> | null;
+    get root(): Store<any>;
+    set length(v: number);
+    get length(): number;
+    set index(v: string | number);
+    get index(): string | number;
+    get no(): string | number;
+    get creatable(): boolean;
+    get immutable(): boolean;
+    set selfNew(v: boolean);
+    get selfNew(): boolean;
+    set new(v: boolean);
+    get new(): boolean;
+    get editable(): boolean;
+    set selfHidden(v: boolean | null);
+    get selfHidden(): boolean | null;
+    set hidden(v: boolean);
+    get hidden(): boolean;
+    set selfClearable(v: boolean | null);
+    get selfClearable(): boolean | null;
+    set clearable(v: boolean);
+    get clearable(): boolean;
+    set selfRequired(v: boolean | null);
+    get selfRequired(): boolean | null;
+    set required(v: boolean);
+    get required(): boolean;
+    set selfDisabled(v: boolean | null);
+    get selfDisabled(): boolean | null;
+    set disabled(v: boolean);
+    get disabled(): boolean;
+    set selfReadonly(v: boolean | null);
+    get selfReadonly(): boolean | null;
+    set readonly(v: boolean);
+    get readonly(): boolean;
+    /**
+     *
+     * @param {string | number} key
+     * @returns {Store?}
+     */
+    child(key: string | number): Store | null;
+    get changed(): boolean;
+    get saved(): boolean;
+    set value(v: T | null);
+    get value(): T | null;
+    set state(v: any);
+    get state(): any;
+    get destroyed(): boolean;
+    destroy(): void;
+    /** @returns {IterableIterator<[key: string | number, value: Store]>} */
+    [Symbol.iterator](): IterableIterator<[key: string | number, value: Store]>;
+    #private;
+}
+declare class ObjectStore extends Store<any> {
+    /**
+     * @param {Schema.Field} schema
+     * @param {object} [options]
+     * @param {Store?} [options.parent]
+     * @param {string | number} [options.index]
+     * @param {boolean} [options.new]
+     * @param {(value: any, index: any) => void} [options.onUpdate]
+     * @param {(value: any, index: any) => void} [options.onUpdateState]
+     */
+    constructor(schema: Schema.Field, { parent, index, new: isNew, onUpdate, onUpdateState }?: {
+        parent?: Store<any> | null | undefined;
+        index?: string | number | undefined;
+        new?: boolean | undefined;
+        onUpdate?: ((value: any, index: any) => void) | undefined;
+        onUpdateState?: ((value: any, index: any) => void) | undefined;
+    });
+    [Symbol.iterator](): Generator<[string, Store<any>], void, unknown>;
+    #private;
+}
+
+/**
+ *
+ * @param {string} source
+ * @param {Layout.Options} [options]
+ * @returns {(Layout.Node | string)[]}
+ */
+declare function parse(source: string, { creteCalc, creteEvent, simpleTag, }?: Options): (Node | string)[];
+
+/**
+ *
+ * @param {Layout.Node | (Layout.Node |string)[]} value
+ * @param {boolean} [formable]
+ * @returns {string}
+ */
+declare function toString(value: Node | (Node | string)[], formable?: boolean): string;
+
+type Directives = {
+    fragment?: boolean | undefined;
+    if?: string | Function | undefined;
+    else?: boolean | undefined;
+    /**
+     * 值关联（关联为列表）
+     */
+    value?: string | undefined;
+    /**
+     * 列表属性枚举
+     */
+    enum?: boolean | undefined;
+    bind?: string | undefined;
+    text?: string | Function | undefined;
+    html?: string | Function | undefined;
+    /**
+     * 注释
+     */
+    comment?: string | Function | undefined;
+};
+type Options = {
+    creteCalc?: ((t: string) => (vars: Record<string, any>) => any) | undefined;
+    creteEvent?: ((t: string) => ($event: any, vars: Record<string, any>) => any) | undefined;
+    simpleTag?: Set<string> | undefined;
+};
+type Node = {
+    name: string;
+    is?: string | null | undefined;
+    id?: string | undefined;
+    attrs: Record<string, string | {
+        name: string;
+    } | ((global: any) => void)>;
+    classes: Record<string, string | boolean | ((global: any) => void)>;
+    styles: Record<string, string | ((global: any) => void)>;
+    events: Record<string, string | (($event: any, global: any) => void)>;
+    vars: Record<string, string | ((global: any) => void)>;
+    aliases: Record<string, string | Function>;
+    directives: Directives;
+    children: (Node | string)[];
+};
+
+type index_d_Directives = Directives;
+type index_d_Node = Node;
+type index_d_Options = Options;
+declare const index_d_parse: typeof parse;
+declare namespace index_d {
+  export { type index_d_Directives as Directives, type index_d_Node as Node, type index_d_Options as Options, index_d_parse as parse, toString as stringify };
+}
+
+/**
+ * @overload
+ * @param {Store} store
+ * @param {(Layout.Node | string)[]} layouts
+ * @param {Element} parent
+ * @param {Record<string, Store | {get?(): any; set?(v: any): void; exec?(...p: any[]): any; calc?(...p: any[]): any }>} [global]
+ * @param {(path: string[]) => Component?} [components]
+ * @returns {() => void}
+ */
+declare function _default(store: Store, layouts: (Node | string)[], parent: Element, global?: Record<string, Store<any> | {
+    get?(): any;
+    set?(v: any): void;
+    exec?(...p: any[]): any;
+    calc?(...p: any[]): any;
+}> | undefined, components?: ((path: string[]) => Component | null) | undefined): () => void;
+/**
+ * @overload
+ * @param {Store} store
+ * @param {(Layout.Node | string)[]} layouts
+ * @param {Element} parent
+ * @param {((path: string[]) => Component?)?} [components]
+ * @returns {() => void}
+ */
+declare function _default(store: Store, layouts: (Node | string)[], parent: Element, components?: ((path: string[]) => Component | null) | null | undefined): () => void;
+
+export { Component, type ComponentGetter, index_d as Layout, Schema, Store, type VerifyError, _default as render };