@okyiww/form 0.0.1

package/dist/types/core/adapter/ArcoVueAdapter.d.ts

@@ -0,0 +1,9 @@
+import { default as Runtime } from '../runtime';
+import { CustomAdapter } from '../../helpers/defineFormSetup/types';
+export declare class ArcoVueAdapter implements CustomAdapter {
+    runtime: Runtime;
+    constructor(runtime: Runtime);
+    formModelName: string;
+    formModelKey: string;
+    validate(): Promise<void>;
+}

package/dist/types/core/adapter/NaiveUIAdapter.d.ts

@@ -0,0 +1,9 @@
+import { default as Runtime } from '../runtime';
+import { CustomAdapter } from '../../helpers/defineFormSetup/types';
+export declare class NaiveUIAdapter implements CustomAdapter {
+    runtime: Runtime;
+    constructor(runtime: Runtime);
+    formModelName: string;
+    formModelKey: string;
+    validate(): Promise<void>;
+}

package/dist/types/core/adapter/NutUIAdapter.d.ts

@@ -0,0 +1,9 @@
+import { default as Runtime } from '../runtime';
+import { CustomAdapter } from '../../helpers/defineFormSetup/types';
+export declare class NutUIAdapter implements CustomAdapter {
+    runtime: Runtime;
+    constructor(runtime: Runtime);
+    formModelName: string;
+    formModelKey: string;
+    validate(): Promise<void>;
+}

package/dist/types/core/adapter/index.d.ts

@@ -0,0 +1,9 @@
+import { default as Runtime } from '../runtime';
+import { CustomAdapter } from '../../helpers/defineFormSetup/types';
+export default class Adapter {
+    runtime: Runtime;
+    presetAdapters: Record<string, any>;
+    adaptee: CustomAdapter;
+    constructor(runtime: Runtime);
+    initAdapters(): void;
+}

package/dist/types/core/context/index.d.ts

@@ -0,0 +1,9 @@
+import { DefineFormSetupOptions, Template } from '../../helpers/defineFormSetup/types';
+import { FormSetupLoader } from '../lifecycle/types';
+export declare class FormContext {
+    static context: DefineFormSetupOptions;
+    static templateById: Record<string, DefineFormSetupOptions["templates"][number]>;
+    static processContext(): void;
+    static parseLoader(loader: FormSetupLoader): Promise<void>;
+    static getTemplate(templateId?: string): Template;
+}

package/dist/types/core/context/types.d.ts

@@ -0,0 +1,25 @@
+export interface SSR {
+    renderComponent: (componentName: string) => any;
+    definitions?: {
+        dispatch?: string;
+        model?: string;
+        shared?: string;
+        res?: string;
+        err?: string;
+        args?: string;
+    };
+    actions: {
+        GET?: (params: AnyObject) => Promise<any>;
+        POST?: (params: AnyObject) => Promise<any>;
+        PUT?: (params: AnyObject) => Promise<any>;
+        DELETE?: (params: AnyObject) => Promise<any>;
+        PATCH?: (params: AnyObject) => Promise<any>;
+        CONDITION?: (params: AnyObject) => Promise<any>;
+        EVENT_HANDLER?: (params: AnyObject) => Promise<any>;
+        SET_MODEL?: (params: AnyObject) => Promise<any>;
+        SET_SHARED?: (params: AnyObject) => Promise<any>;
+        GET_MODEL?: (params: AnyObject) => Promise<any>;
+        GET_SHARED?: (params: AnyObject) => Promise<any>;
+        REFS?: (params: AnyObject) => Promise<any>;
+    } & AnyObject;
+}

package/dist/types/core/lifecycle/Model/index.d.ts

@@ -0,0 +1,31 @@
+import { Metadata } from '../Schema/types';
+import { default as Runtime } from '../../runtime';
+export default class Model {
+    runtime: Runtime;
+    constructor(runtime: Runtime);
+    /**
+     * 我们知道 model 的关键是 field 和 defaultValue, 由于我们根本不知道这个过程什么时候
+     * 会触发到谁，有可能都是异步，我们也不知道谁先执行，但是对于初始化 model 来说，我们知道，一定有
+     * 一个同 path 的 field 对应一个同 path 的 defaultValue，如果处理完都还没有结束，那么剩下的
+     * 就是没有提供 defaultValue 的 field，那么我们再给他设置为 undefined
+     */
+    relationMap: Map<string, any>;
+    model: import('vue').Ref<Record<string, any>, Record<string, any>>;
+    immutableModel: {};
+    allConsumed: import('vue').Ref<boolean, boolean>;
+    processRelation(metadata: Metadata, value: any): void;
+    consumeRelation(path: string): void;
+    /**
+     * 让我们先来明确一些现状
+     * 由于整个解析过程是无状态无依赖无顺序的，所以我们并不清楚谁先来后到，所以在这种场景下，数据一定要非常的干净有逻辑
+     * 1、无 field 的类型不会被计入 ralationMap
+     * 2、如果一个消费关系的 path 包含了 children，那么它可能是在 group 里，也可能是在 list 里
+     * 3、如果一个消费关系的 path 包含了 children，并且 relationMap 中存在 path 是当前 path 的前缀，那么它一定是在 list 里
+     * 4、同理，如果找不到这样的前缀，那么它一定是在 group 里
+     */
+    consume(relation: Record<string, any>): void;
+    defaultValueCalcByType(type: string): never[] | undefined;
+    resolveRelations(relations: Record<string, any>[], basePath?: string): void;
+    isAllConsumed(): boolean;
+    checkingConsume(): void;
+}

package/dist/types/core/lifecycle/Render/index.d.ts

@@ -0,0 +1,54 @@
+import { ParsedSchema } from '../Schema/types';
+import { default as Runtime } from '../../runtime';
+export default class Render {
+    runtime: Runtime;
+    meta: {
+        Form: any;
+        FormItem: any;
+        layouts: ({
+            Item: import('../../../helpers/defineFormSetup/types').Component;
+            Group: import('../../../helpers/defineFormSetup/types').Component;
+            List: import('../../../helpers/defineFormSetup/types').Component;
+            ListItem: import('../../../helpers/defineFormSetup/types').Component;
+        } & Record<string, any>) | ({
+            Item: import('../../../helpers/defineFormSetup/types').Component;
+            Group: import('../../../helpers/defineFormSetup/types').Component;
+            List: import('../../../helpers/defineFormSetup/types').Component;
+            ListItem: import('../../../helpers/defineFormSetup/types').Component;
+        } & Record<string, any>) | ({
+            Item: import('../../../helpers/defineFormSetup/types').Component;
+            Group: import('../../../helpers/defineFormSetup/types').Component;
+            List: import('../../../helpers/defineFormSetup/types').Component;
+            ListItem: import('../../../helpers/defineFormSetup/types').Component;
+        } & Record<string, any>);
+        adapters: {};
+    };
+    formRef: import('vue').Ref<any, any>;
+    constructor(runtime: Runtime);
+    getRenderMeta(): {
+        Form: any;
+        FormItem: any;
+        layouts: ({
+            Item: import('../../../helpers/defineFormSetup/types').Component;
+            Group: import('../../../helpers/defineFormSetup/types').Component;
+            List: import('../../../helpers/defineFormSetup/types').Component;
+            ListItem: import('../../../helpers/defineFormSetup/types').Component;
+        } & Record<string, any>) | ({
+            Item: import('../../../helpers/defineFormSetup/types').Component;
+            Group: import('../../../helpers/defineFormSetup/types').Component;
+            List: import('../../../helpers/defineFormSetup/types').Component;
+            ListItem: import('../../../helpers/defineFormSetup/types').Component;
+        } & Record<string, any>) | ({
+            Item: import('../../../helpers/defineFormSetup/types').Component;
+            Group: import('../../../helpers/defineFormSetup/types').Component;
+            List: import('../../../helpers/defineFormSetup/types').Component;
+            ListItem: import('../../../helpers/defineFormSetup/types').Component;
+        } & Record<string, any>);
+        adapters: {};
+    };
+    renderItemSchema(schema: ParsedSchema, modelSource?: Record<string, any>, baseFieldPath?: string, Layout?: any): false | import("vue/jsx-runtime").JSX.Element | undefined;
+    renderListSchema(schema: ParsedSchema, modelSource?: Record<string, any>, baseFieldPath?: string, baseModelPath?: string, Layout?: any): import("vue/jsx-runtime").JSX.Element;
+    renderGroupSchema(schema: ParsedSchema, modelSource?: Record<string, any>, baseFieldPath?: string, Layout?: any): import("vue/jsx-runtime").JSX.Element;
+    renderParsedSchema(schema: ParsedSchema, modelSource?: Record<string, any>, baseFieldPath?: string, baseModelPath?: string): false | import("vue/jsx-runtime").JSX.Element | undefined;
+    render(): import('vue').DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}

package/dist/types/core/lifecycle/Schema/index.d.ts

@@ -0,0 +1,48 @@
+import { Metadata, ParsedSchemas } from './types';
+import { default as Runtime } from '../../runtime';
+import { RawSchemas } from '../../../helpers/defineFormSchema/types';
+import { Ref } from 'vue';
+export default class Schema {
+    runtime: Runtime;
+    rawSchemas: RawSchemas | undefined;
+    parsedSchemas: Ref<ParsedSchemas>;
+    refs: Map<string, any>;
+    constructor(runtime: Runtime);
+    processSSR(schemas: RawSchemas): RawSchemas;
+    processSchemas(): void;
+    traverseSchemas(schemas: RawSchemas): void;
+    /**
+     * 需要注意的是，当我在实现这个的时候，我的 happy path 其实是过分关注于 input => renderable 的，这
+     * 其实很大程度上存在风险，稍有不慎就会带来不可避免的重构难度，对此，除了谨慎考虑引入之外，我还建议在设计之初
+     * 就引入足够复杂的场景，避免过于 happy path 导致复用性差并且代码复杂的问题
+     */
+    parseSchema(schema: any, metadata: Metadata): void;
+    /**
+     * 先说说这个函数做什么，防止后续误用，乱用
+     * 这个函数并不是只用来处理 schema 的第一层遍历，而是一个通用型的函数，他的目的是用来处理任意键值对
+     * 并且将处理的结果妥善的根据 metadata 设定到应该去的地方，那么可以想象到的是
+     * 这个函数的出口是固定的，但是入口是不固定的，所以我会约束这个函数的出口返回的参数，但需要入口来适配这些参数才能正常使用它
+     *
+     * 那么这个函数的目的也就明了了，
+     * 1、得到处理完成的值
+     *    1、什么是处理完成？
+     *    2、什么该处理，什么不该处理？
+     *    3、怎么处理？
+     * 2、调用 metadata 里的 setter，并且将处理完成的值和 metadata 传入
+     */
+    parseProperty(propertyKey: string, propertyValue: any, metadata: Metadata): void;
+    usageTracker: Map<string, Set<string>>;
+    /**
+     * 处理器
+     * 1、返回值是什么
+     * 2、什么该处理，什么不处理
+     *
+     * 处理器需要跟 Update 打通，留存记录
+     *
+     * 思路
+     * 对于函数而言，将所有同步或异步的函数都处理成结果后，再进入 processNonFunction 函数进行处理，而对于其他数据，则直接进入
+     * processNonFunction 函数进行处理
+     */
+    processing(value: any, metadata: Metadata): void;
+    processingNonFunction(value: any, metadata: Metadata, jumpConsume?: boolean): void;
+}

package/dist/types/core/lifecycle/Schema/types.d.ts

@@ -0,0 +1,8 @@
+export type ParsedSchema = Record<string, any>;
+export type ParsedSchemas = ParsedSchema[];
+export type Metadata = {
+    path: string;
+    setter: (...args: any[]) => any;
+    propertyKey?: string;
+    processedSetter?: (processedValue: any, jumpConsume?: boolean) => void;
+};

package/dist/types/core/lifecycle/Update/index.d.ts

@@ -0,0 +1,9 @@
+import { TriggerType } from './types';
+import { default as Runtime } from '../../runtime';
+export default class Update {
+    runtime: Runtime;
+    effects: Map<any, any>;
+    constructor(runtime: Runtime);
+    track(key: string, effect: any): void;
+    trigger(type?: TriggerType, path?: string): void;
+}

package/dist/types/core/lifecycle/Update/types.d.ts

@@ -0,0 +1 @@
+export type TriggerType = "model" | "share";

package/dist/types/core/lifecycle/hooks/useBaseStyle.d.ts

@@ -0,0 +1 @@
+export declare function useBaseStyle(value?: number): AnyObject;

package/dist/types/core/lifecycle/hooks/useDispatchHandler/index.d.ts

@@ -0,0 +1,6 @@
+import { default as Runtime } from '../../../runtime';
+export declare const requestResSymbol: unique symbol;
+export declare const requestErrSymbol: unique symbol;
+export declare const eventArgsSymbol: unique symbol;
+export declare function processDispatch(data: AnyObject, utils: AnyObject, runtime: Runtime, runtimeInfo?: AnyObject): Promise<any>;
+export declare function useDispatchHandler(data: any, runtime: Runtime): (utils: AnyObject) => Promise<any>;

package/dist/types/core/lifecycle/hooks/useDispatchHandler/is.d.ts

@@ -0,0 +1,8 @@
+export declare function isRequestDispatch(dispatch: string): boolean;
+export declare function isConditionDispatch(dispatch: string): boolean;
+export declare function isEventHandlerDispatch(dispatch: string): boolean;
+export declare function isSetModelDispatch(dispatch: string): boolean;
+export declare function isSetSharedDispatch(dispatch: string): boolean;
+export declare function isGetModelDispatch(dispatch: string): boolean;
+export declare function isGetSharedDispatch(dispatch: string): boolean;
+export declare function isRefsDispatch(dispatch: string): boolean;

package/dist/types/core/lifecycle/hooks/useDispatchHandler/processCompare.d.ts

@@ -0,0 +1,7 @@
+import { default as Runtime } from '../../../runtime';
+/**
+ * skipProcess 的引入是为了支持 left 和 right 以及 rightValues 都是 dispatch 的情况
+ * 但由于不推荐进行超级定制的 dispatch，因为数据本身就已经在后端了，能够尽可能拼好的不需要太动态的可以略过
+ * 所以这里不做深度的处理，只处理第一层的情况
+ */
+export declare function processCompare(data: AnyObject, utils: AnyObject, runtime: Runtime, runtimeInfo?: AnyObject, skipProcess?: boolean): Promise<boolean>;

package/dist/types/core/lifecycle/hooks/useDispatchHandler/processDynamicValue.d.ts

@@ -0,0 +1,7 @@
+import { default as Runtime } from '../../../runtime';
+export declare function isDynamicValue(value: string, runtime: Runtime): boolean;
+export declare function processDynamicValue(value: string | AnyObject | AnyArray, { model, shared }: AnyObject, runtime: Runtime, runtimeInfo?: AnyObject): any;
+export declare function processArrayDynamic(value: any[], { model, shared }: AnyObject, runtime: Runtime, runtimeInfo?: AnyObject): any[];
+export declare function processPlainObjectDynamic(value: Record<string, any>, { model, shared }: AnyObject, runtime: Runtime, runtimeInfo?: AnyObject): {
+    [k: string]: any;
+};

package/dist/types/core/lifecycle/hooks/useDispatchHandler/processRequests.d.ts

@@ -0,0 +1,2 @@
+import { default as Runtime } from '../../../runtime';
+export declare function processRequests(dispatch: keyof typeof runtime.ssr.actions, data: AnyObject, utils: AnyObject, runtime: Runtime, runtimeInfo?: AnyObject): Promise<any>;

package/dist/types/core/lifecycle/hooks/useDispatchHandler/processTransform.d.ts

@@ -0,0 +1 @@
+export declare function processTransform(data: any, transform: AnyObject): any;

package/dist/types/core/lifecycle/hooks/useFormItemProps.d.ts

@@ -0,0 +1,2 @@
+import { default as Runtime } from '../../runtime';
+export declare function useFormItemProps(runtime: Runtime, schema: any, baseFieldPath?: string): any;

package/dist/types/core/lifecycle/hooks/useFormProps.d.ts

@@ -0,0 +1,2 @@
+import { default as Runtime } from '../../runtime';
+export declare function useFormProps(runtime: Runtime): any;

package/dist/types/core/lifecycle/hooks/useLabel.d.ts

@@ -0,0 +1 @@
+export declare function useLabel(label: string | AnyFunction, baseFieldPath?: string): any;

package/dist/types/core/lifecycle/hooks/useLayout.d.ts

@@ -0,0 +1,2 @@
+import { default as Runtime } from '../../runtime';
+export declare function useLayout(runtime: Runtime, schema: any, fallback?: string): any;

package/dist/types/core/lifecycle/hooks/useLayoutStyle.d.ts

@@ -0,0 +1,15 @@
+/**
+ * TODO：一种简单的布局计算，可能带来的问题是在存在 px 转换的情况下，这个布局不会很精准，16px 和实际的项目 px 可能存在差异
+ * 后续有需要的话可以提供一个 px 的定义器，毕竟移动端上需要这种布局的场景也不多
+ */
+export declare function useLayoutStyle(schema: AnyObject, layoutGap?: number): {
+    width: string;
+    display?: undefined;
+    boxSizing?: undefined;
+    verticalAlign?: undefined;
+} | {
+    width: string;
+    display: string;
+    boxSizing: string;
+    verticalAlign: string;
+};

package/dist/types/core/lifecycle/hooks/usePathTracker.d.ts

@@ -0,0 +1 @@
+export declare function usePathTracker<T extends object>(target: T, onAccess: (path: string) => void): T;

package/dist/types/core/lifecycle/hooks/usePlaceholder.d.ts

@@ -0,0 +1 @@
+export declare function usePlaceholder(label: string, componentName?: string): string | undefined;

package/dist/types/core/lifecycle/hooks/useRules.d.ts

@@ -0,0 +1 @@
+export declare function useRules(schema: AnyObject): any;

package/dist/types/core/lifecycle/hooks/useSSRComponent.d.ts

@@ -0,0 +1,2 @@
+import { default as Runtime } from '../../runtime';
+export declare function useSSRComponent(componentName: string, runtime: Runtime): () => Promise<any>;

package/dist/types/core/lifecycle/types.d.ts

@@ -0,0 +1,4 @@
+import { DefineFormSetupOptions } from '../../helpers/defineFormSetup/types';
+export type FormSetupLoader = () => Promise<{
+    default: DefineFormSetupOptions;
+}>;

package/dist/types/core/runtime/index.d.ts

@@ -0,0 +1,37 @@
+import { default as Adapter } from '../adapter';
+import { FormContext } from '../context';
+import { SSR } from '../context/types';
+import { default as Model } from '../lifecycle/Model';
+import { default as Render } from '../lifecycle/Render';
+import { default as Schema } from '../lifecycle/Schema';
+import { default as Update } from '../lifecycle/Update';
+import { Component } from '../../helpers/defineFormSetup/types';
+import { UseFormOptions } from '../../helpers/useForm/types';
+export default class Runtime {
+    _schema: Schema;
+    _model: Model;
+    _render: Render;
+    _update: Update;
+    _options: UseFormOptions;
+    _context: FormContext;
+    _adapter: Adapter;
+    shared: {};
+    isSsr: boolean;
+    ssr: SSR;
+    defaultSSRDefinitions: {
+        dispatch: string;
+        model: string;
+        shared: string;
+        res: string;
+        err: string;
+        args: string;
+    };
+    constructor(options: UseFormOptions);
+    processSSR(options: UseFormOptions): void;
+    render(): Component;
+    submit(): Promise<Record<string, any>>;
+    share(shared: AnyObject): void;
+    isReady(handler: AnyFunction): void;
+    hydrate(model: AnyObject): void;
+    getFormRef(): import('vue').Ref<any, any>;
+}

package/dist/types/core/services/checkPath.d.ts

@@ -0,0 +1,10 @@
+export declare function getParentPaths(path: string): string[];
+export declare function getDirectParent(path: string): string | null;
+export declare function checkParentExists(map: Map<string, any>, childPath: string): boolean;
+export declare function checkRelations(map: Map<string, any>, childPath: string): {
+    isListChild: boolean;
+    existingRelations: {
+        current: any;
+        parent: any;
+    }[];
+};

package/dist/types/core/services/deepTraverse.d.ts

@@ -0,0 +1,35 @@
+export interface TraverseContext {
+    /**
+     * 当前节点在父节点中的 key（如果是数组，则为索引）
+     */
+    key: string | number;
+    /**
+     * 从根到当前节点的路径数组
+     */
+    path: (string | number)[];
+    /**
+     * 当前节点的父节点（对象或数组）
+     */
+    parent: any;
+    /**
+     * 检查当前节点是否为叶子节点（没有子节点）
+     */
+    isLeaf: boolean;
+}
+/**
+ * 遍历处理函数
+ * @param value 当前节点的值
+ * @param context 当前节点的上下文
+ * @returns 返回新值。
+ * - 返回 `SKIP`：跳过子节点遍历。
+ * - 返回 `DELETE`：删除此节点。
+ * - 返回其他值：用该值替换当前节点。
+ */
+export type TraverseHandler = (value: any, context: TraverseContext) => any;
+/**
+ * 深度遍历一个对象或数组，并允许通过 handler "原地" 修改、跳过或删除节点。
+ * @param target 要遍历的对象或数组
+ * @param handler 在每个节点上调用的处理函数
+ * @returns 经过 handler 修改后的原始对象 (in-place)
+ */
+export declare function deepTraverse<T extends object>(target: T, handler: TraverseHandler): T;

package/dist/types/core/services/index.d.ts

@@ -0,0 +1,5 @@
+export * from './traverse';
+export * from './isPromise';
+export * from './isValidComponent';
+export * from './isNumericLike';
+export * from './checkPath';

package/dist/types/core/services/isNumericLike.d.ts

@@ -0,0 +1 @@
+export declare function isNumericLike(value: string): boolean;

package/dist/types/core/services/isPromise.d.ts

@@ -0,0 +1 @@
+export declare function isPromise(value: any): boolean;

package/dist/types/core/services/isValidComponent.d.ts

@@ -0,0 +1 @@
+export declare function isValidComponent(propertyKey: string | undefined, value: any): boolean;

package/dist/types/core/services/traverse.d.ts

@@ -0,0 +1,2 @@
+export declare function wrapperNumericLike(value: string): string;
+export declare function traverse(tree: Record<string, any>, visitor: (node: any, key: string, parentKey?: string) => boolean | void, parentKey?: string): void;

package/dist/types/helpers/defineFormSchema/index.d.ts

@@ -0,0 +1,2 @@
+import { RawSchemas } from './types';
+export declare function defineFormSchema(schemas: RawSchemas): RawSchemas;

package/dist/types/helpers/defineFormSchema/types.d.ts

@@ -0,0 +1,6 @@
+export type RawSchemas = RawSchema[];
+export type RawSchema = {
+    formItemProps?: any;
+    formItemSlots?: any;
+    [key: string]: any;
+};

package/dist/types/helpers/defineFormSetup/index.d.ts

@@ -0,0 +1,2 @@
+import { DefineFormSetupOptions } from './types';
+export declare function defineFormSetup(options: DefineFormSetupOptions): DefineFormSetupOptions;

package/dist/types/helpers/defineFormSetup/types.d.ts

@@ -0,0 +1,54 @@
+export type Component = any;
+export type BuiltInAdapter = "ArcoVue" | (string & {});
+export type CustomAdapter = {
+    formModelName: string;
+    formModelKey: string;
+    validate: () => Promise<void>;
+};
+export type Template = {
+    id: string;
+    adapter: BuiltInAdapter;
+    providers: {
+        Form: Component;
+        FormItem: Component;
+        layouts: {
+            Item: Component;
+            Group: Component;
+            List: Component;
+            ListItem: Component;
+        } & Record<string, Component>;
+    };
+} | {
+    id: string;
+    customAdapter: CustomAdapter;
+    providers: {
+        Form: Component;
+        FormItem: Component;
+        layouts: {
+            Item: Component;
+            Group: Component;
+            List: Component;
+            ListItem: Component;
+        } & Record<string, Component>;
+    };
+} | {
+    id: string;
+    adapter: BuiltInAdapter;
+    customAdapter: Partial<CustomAdapter>;
+    providers: {
+        Form: Component;
+        FormItem: Component;
+        layouts: {
+            Item: Component;
+            Group: Component;
+            List: Component;
+            ListItem: Component;
+        } & Record<string, Component>;
+    };
+};
+export type DefineFormSetupOptions = {
+    templates: Template[];
+    default: {
+        templateId: string;
+    };
+};

package/dist/types/helpers/index.d.ts

@@ -0,0 +1,6 @@
+export * from './defineFormSetup';
+export * from './defineFormSchema';
+export * from './initForm';
+export * from './useForm';
+export * from './raw';
+export * from './once';

package/dist/types/helpers/initForm/index.d.ts

@@ -0,0 +1,4 @@
+import { InitFormOptions } from './types';
+export declare const initForm: {
+    install(app: any, options: InitFormOptions): void;
+};

package/dist/types/helpers/initForm/types.d.ts

@@ -0,0 +1,5 @@
+import { FormSetupLoader } from '../../core/lifecycle/types';
+export type InitFormOptions = {
+    loader: FormSetupLoader;
+    env: "weapp" | "web";
+};

package/dist/types/helpers/once/index.d.ts

@@ -0,0 +1,2 @@
+export declare function once(value: any): any;
+export declare function isOnce(value: any): boolean;

package/dist/types/helpers/raw/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 我来说明一下我希望这个函数干啥
+ * 首先，我希望函数可以自己判断传入的参数是 object 还是 function
+ *
+ * 并且根据 object 还是 function 进行对应的标记
+ * 我还会推出 isRaw 的方法，在应用层使用，作为判断要不要处理的依据
+ */
+export declare function raw(value: any): any;
+export declare function isRaw(value: any): boolean;

package/dist/types/helpers/useForm/index.d.ts

@@ -0,0 +1,5 @@
+import { UseFormOptions } from './types';
+/**
+ * Todo: docs
+ */
+export declare function useForm(options: UseFormOptions): any[];

package/dist/types/helpers/useForm/types.d.ts

@@ -0,0 +1,10 @@
+import { SSR } from '../../core/context/types';
+import { RawSchemas } from '../defineFormSchema/types';
+export type UseFormOptions = {
+    templateId?: string;
+    schemas: RawSchemas | ((...args: any[]) => RawSchemas) | ((...args: any[]) => Promise<RawSchemas>);
+    layoutGap?: number;
+    formProps?: any;
+    formSlots?: any;
+    ssr?: SSR;
+};

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+declare const version = "0.0.0";
+export { version };
+export * from './core/context';
+export * from './helpers';

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@okyiww/form",
+  "version": "0.0.1",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "type": "module",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "author": "okyiww <okyiww@gmail.com>",
+  "repository": "okyiww/form",
+  "keywords": [
+    "form builder",
+    "vue",
+    "typescript"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/lodash": "^4.17.20",
+    "@vitejs/plugin-vue-jsx": "^4.1.2",
+    "nodemon": "^3.1.9",
+    "vite": "^6.2.2",
+    "vite-plugin-dts": "^4.5.3",
+    "vue": "^3.5.13",
+    "vue-tsc": "^2.2.4",
+    "@okyiww/nexus": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.13"
+  },
+  "dependencies": {
+    "@changesets/changelog-git": "^0.2.1",
+    "@vue/reactivity": "^3.5.22",
+    "lodash": "^4.17.21",
+    "on-change": "^6.0.1"
+  },
+  "scripts": {
+    "dev": "nodemon -e .ts,.tsx --ignore dist --exec 'vite build --mode development'",
+    "build": "vue-tsc && vite build",
+    "release": "pnpm build --mode production && pnpm changeset publish"
+  }
+}