npm - @voxgig/apidef - Versions diffs - 1.9.0 → 2.0.2 - Mend

@voxgig/apidef 1.9.0 → 2.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (73) hide show

package/dist/apidef.d.ts +3 -29
package/dist/apidef.js +65 -186
package/dist/apidef.js.map +1 -1
package/dist/builder/entity/apiEntity.d.ts +3 -0
package/dist/builder/entity/apiEntity.js +51 -0
package/dist/builder/entity/apiEntity.js.map +1 -0
package/dist/builder/entity/def.d.ts +3 -0
package/dist/builder/entity/def.js +19 -0
package/dist/builder/entity/def.js.map +1 -0
package/dist/builder/entity.d.ts +2 -0
package/dist/builder/entity.js +30 -0
package/dist/builder/entity.js.map +1 -0
package/dist/builder/flow/flowHeuristic01.d.ts +2 -0
package/dist/builder/flow/flowHeuristic01.js +153 -0
package/dist/builder/flow/flowHeuristic01.js.map +1 -0
package/dist/builder/flow.d.ts +2 -0
package/dist/builder/flow.js +41 -0
package/dist/builder/flow.js.map +1 -0
package/dist/guide/heuristic01.d.ts +2 -0
package/dist/guide/heuristic01.js +119 -0
package/dist/guide/heuristic01.js.map +1 -0
package/dist/guide.d.ts +2 -0
package/dist/guide.js +60 -0
package/dist/guide.js.map +1 -0
package/dist/parse.d.ts +1 -1
package/dist/parse.js +5 -4
package/dist/parse.js.map +1 -1
package/dist/resolver.d.ts +2 -0
package/dist/resolver.js +62 -0
package/dist/resolver.js.map +1 -0
package/dist/transform/entity.js +25 -4
package/dist/transform/entity.js.map +1 -1
package/dist/transform/field.js +4 -84
package/dist/transform/field.js.map +1 -1
package/dist/transform/operation.d.ts +2 -2
package/dist/transform/operation.js +60 -30
package/dist/transform/operation.js.map +1 -1
package/dist/transform/top.d.ts +2 -2
package/dist/transform/top.js +5 -4
package/dist/transform/top.js.map +1 -1
package/dist/transform.d.ts +1 -1
package/dist/transform.js +20 -10
package/dist/transform.js.map +1 -1
package/dist/tsconfig.tsbuildinfo +1 -1
package/dist/types.d.ts +691 -0
package/dist/types.js +39 -0
package/dist/types.js.map +1 -0
package/dist/utility.d.ts +5 -0
package/dist/utility.js +84 -0
package/dist/utility.js.map +1 -0
package/model/apidef.jsonic +28 -24
package/package.json +9 -7
package/src/apidef.ts +94 -271
package/src/builder/entity/apiEntity.ts +88 -0
package/src/builder/entity/def.ts +44 -0
package/src/builder/entity.ts +54 -0
package/src/builder/flow/flowHeuristic01.ts +200 -0
package/src/builder/flow.ts +61 -0
package/src/guide/heuristic01.ts +178 -0
package/src/guide.ts +87 -0
package/src/parse.ts +6 -4
package/src/resolver.ts +91 -0
package/src/transform/entity.ts +36 -10
package/src/transform/field.ts +9 -92
package/src/transform/operation.ts +112 -46
package/src/transform/top.ts +11 -9
package/src/transform.ts +22 -11
package/src/types.ts +89 -0
package/src/utility.ts +161 -0
package/dist/transform/manual.d.ts +0 -3
package/dist/transform/manual.js +0 -12
package/dist/transform/manual.js.map +0 -1
package/src/transform/manual.ts +0 -29

package/dist/types.d.ts ADDED Viewed

@@ -0,0 +1,691 @@
+import * as Fs from 'node:fs';
+import { Pino, prettyPino } from '@voxgig/util';
+type FsUtil = typeof Fs;
+type Log = ReturnType<typeof prettyPino>;
+type ApiDefOptions = {
+    def?: string;
+    fs?: any;
+    pino?: ReturnType<typeof Pino>;
+    debug?: boolean | string;
+    folder?: string;
+    meta?: Record<string, any>;
+    outprefix?: string;
+    strategy?: string;
+};
+declare const ModelShape: {
+    <V>(root?: V | undefined, ctx?: import("gubu").Context): V & {
+        name: string;
+        def: string;
+        main: {
+            sdk: {};
+            def: {};
+            api: {
+                guide: {};
+                entity: {};
+            };
+        };
+    };
+    valid: <V>(root?: V | undefined, ctx?: import("gubu").Context) => root is V & {
+        name: StringConstructor;
+        def: StringConstructor;
+        main: {
+            sdk: {};
+            def: {};
+            api: {
+                guide: {};
+                entity: {};
+            };
+        };
+    };
+    match(root?: any, ctx?: import("gubu").Context): boolean;
+    error(root?: any, ctx?: import("gubu").Context): {
+        gubu: boolean;
+        code: string;
+        gname: string;
+        props: ({
+            path: string;
+            type: string;
+            value: any;
+        }[]);
+        desc: () => ({
+            name: string;
+            code: string;
+            err: {
+                key: string;
+                type: string;
+                node: import("gubu").Node<any>;
+                value: any;
+                path: string;
+                why: string;
+                check: string;
+                args: Record<string, any>;
+                mark: number;
+                text: string;
+                use: any;
+            }[];
+            ctx: any;
+        });
+        toJSON(): /*elided*/ any & {
+            err: any;
+            name: string;
+            message: string;
+        };
+        name: string;
+        message: string;
+        stack?: string;
+    }[];
+    spec(): any;
+    node(): import("gubu").Node<{
+        name: StringConstructor;
+        def: StringConstructor;
+        main: {
+            sdk: {};
+            def: {};
+            api: {
+                guide: {};
+                entity: {};
+            };
+        };
+    }>;
+    stringify(...rest: any[]): string;
+    jsonify(): any;
+    toString(this: any): string;
+    gubu: {
+        gubu$: symbol;
+        v$: string;
+    };
+};
+declare const OpenModelShape: {
+    <V>(root?: V | undefined, ctx?: import("gubu").Context): V & {
+        valid: {};
+        match: {};
+        error: {};
+        spec: {};
+        node: {};
+        stringify: {};
+        jsonify: {};
+        toString: {};
+        gubu: {
+            gubu$: symbol;
+            v$: string;
+        };
+    };
+    valid: <V>(root?: V | undefined, ctx?: import("gubu").Context) => root is V & {
+        <V_1>(root?: V_1 | undefined, ctx?: import("gubu").Context): V_1 & {
+            name: string;
+            def: string;
+            main: {
+                sdk: {};
+                def: {};
+                api: {
+                    guide: {};
+                    entity: {};
+                };
+            };
+        };
+        valid: <V_1>(root?: V_1 | undefined, ctx?: import("gubu").Context) => root is V_1 & {
+            name: StringConstructor;
+            def: StringConstructor;
+            main: {
+                sdk: {};
+                def: {};
+                api: {
+                    guide: {};
+                    entity: {};
+                };
+            };
+        };
+        match(root?: any, ctx?: import("gubu").Context): boolean;
+        error(root?: any, ctx?: import("gubu").Context): {
+            gubu: boolean;
+            code: string;
+            gname: string;
+            props: ({
+                path: string;
+                type: string;
+                value: any;
+            }[]);
+            desc: () => ({
+                name: string;
+                code: string;
+                err: {
+                    key: string;
+                    type: string;
+                    node: import("gubu").Node<any>;
+                    value: any;
+                    path: string;
+                    why: string;
+                    check: string;
+                    args: Record<string, any>;
+                    mark: number;
+                    text: string;
+                    use: any;
+                }[];
+                ctx: any;
+            });
+            toJSON(): /*elided*/ any & {
+                err: any;
+                name: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+        }[];
+        spec(): any;
+        node(): import("gubu").Node<{
+            name: StringConstructor;
+            def: StringConstructor;
+            main: {
+                sdk: {};
+                def: {};
+                api: {
+                    guide: {};
+                    entity: {};
+                };
+            };
+        }>;
+        stringify(...rest: any[]): string;
+        jsonify(): any;
+        toString(this: any): string;
+        gubu: {
+            gubu$: symbol;
+            v$: string;
+        };
+    };
+    match(root?: any, ctx?: import("gubu").Context): boolean;
+    error(root?: any, ctx?: import("gubu").Context): {
+        gubu: boolean;
+        code: string;
+        gname: string;
+        props: ({
+            path: string;
+            type: string;
+            value: any;
+        }[]);
+        desc: () => ({
+            name: string;
+            code: string;
+            err: {
+                key: string;
+                type: string;
+                node: import("gubu").Node<any>;
+                value: any;
+                path: string;
+                why: string;
+                check: string;
+                args: Record<string, any>;
+                mark: number;
+                text: string;
+                use: any;
+            }[];
+            ctx: any;
+        });
+        toJSON(): /*elided*/ any & {
+            err: any;
+            name: string;
+            message: string;
+        };
+        name: string;
+        message: string;
+        stack?: string;
+    }[];
+    spec(): any;
+    node(): import("gubu").Node<{
+        <V>(root?: V | undefined, ctx?: import("gubu").Context): V & {
+            name: string;
+            def: string;
+            main: {
+                sdk: {};
+                def: {};
+                api: {
+                    guide: {};
+                    entity: {};
+                };
+            };
+        };
+        valid: <V>(root?: V | undefined, ctx?: import("gubu").Context) => root is V & {
+            name: StringConstructor;
+            def: StringConstructor;
+            main: {
+                sdk: {};
+                def: {};
+                api: {
+                    guide: {};
+                    entity: {};
+                };
+            };
+        };
+        match(root?: any, ctx?: import("gubu").Context): boolean;
+        error(root?: any, ctx?: import("gubu").Context): {
+            gubu: boolean;
+            code: string;
+            gname: string;
+            props: ({
+                path: string;
+                type: string;
+                value: any;
+            }[]);
+            desc: () => ({
+                name: string;
+                code: string;
+                err: {
+                    key: string;
+                    type: string;
+                    node: import("gubu").Node<any>;
+                    value: any;
+                    path: string;
+                    why: string;
+                    check: string;
+                    args: Record<string, any>;
+                    mark: number;
+                    text: string;
+                    use: any;
+                }[];
+                ctx: any;
+            });
+            toJSON(): /*elided*/ any & {
+                err: any;
+                name: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+        }[];
+        spec(): any;
+        node(): import("gubu").Node<{
+            name: StringConstructor;
+            def: StringConstructor;
+            main: {
+                sdk: {};
+                def: {};
+                api: {
+                    guide: {};
+                    entity: {};
+                };
+            };
+        }>;
+        stringify(...rest: any[]): string;
+        jsonify(): any;
+        toString(this: any): string;
+        gubu: {
+            gubu$: symbol;
+            v$: string;
+        };
+    }>;
+    stringify(...rest: any[]): string;
+    jsonify(): any;
+    toString(this: any): string;
+    gubu: {
+        gubu$: symbol;
+        v$: string;
+    };
+};
+type Model = ReturnType<typeof ModelShape>;
+declare const BuildShape: {
+    <V>(root?: V | undefined, ctx?: import("gubu").Context): V & {
+        spec: {
+            base: string;
+            path: string;
+            debug: string;
+            use: {};
+            res: never[];
+            require: string;
+            log: {};
+            fs: any;
+            watch: {
+                mod: boolean;
+                add: boolean;
+                rem: boolean;
+            };
+        };
+    };
+    valid: <V>(root?: V | undefined, ctx?: import("gubu").Context) => root is V & {
+        spec: {
+            base: string;
+            path: string;
+            debug: string;
+            use: {};
+            res: never[];
+            require: string;
+            log: {};
+            fs: import("gubu").Node<unknown>;
+            watch: {
+                mod: boolean;
+                add: boolean;
+                rem: boolean;
+            };
+        };
+    };
+    match(root?: any, ctx?: import("gubu").Context): boolean;
+    error(root?: any, ctx?: import("gubu").Context): {
+        gubu: boolean;
+        code: string;
+        gname: string;
+        props: ({
+            path: string;
+            type: string;
+            value: any;
+        }[]);
+        desc: () => ({
+            name: string;
+            code: string;
+            err: {
+                key: string;
+                type: string;
+                node: import("gubu").Node<any>;
+                value: any;
+                path: string;
+                why: string;
+                check: string;
+                args: Record<string, any>;
+                mark: number;
+                text: string;
+                use: any;
+            }[];
+            ctx: any;
+        });
+        toJSON(): /*elided*/ any & {
+            err: any;
+            name: string;
+            message: string;
+        };
+        name: string;
+        message: string;
+        stack?: string;
+    }[];
+    spec(): any;
+    node(): import("gubu").Node<{
+        spec: {
+            base: string;
+            path: string;
+            debug: string;
+            use: {};
+            res: never[];
+            require: string;
+            log: {};
+            fs: import("gubu").Node<unknown>;
+            watch: {
+                mod: boolean;
+                add: boolean;
+                rem: boolean;
+            };
+        };
+    }>;
+    stringify(...rest: any[]): string;
+    jsonify(): any;
+    toString(this: any): string;
+    gubu: {
+        gubu$: symbol;
+        v$: string;
+    };
+};
+declare const OpenBuildShape: {
+    <V>(root?: V | undefined, ctx?: import("gubu").Context): V & {
+        valid: {};
+        match: {};
+        error: {};
+        spec: {};
+        node: {};
+        stringify: {};
+        jsonify: {};
+        toString: {};
+        gubu: {
+            gubu$: symbol;
+            v$: string;
+        };
+    };
+    valid: <V>(root?: V | undefined, ctx?: import("gubu").Context) => root is V & {
+        <V_1>(root?: V_1 | undefined, ctx?: import("gubu").Context): V_1 & {
+            spec: {
+                base: string;
+                path: string;
+                debug: string;
+                use: {};
+                res: never[];
+                require: string;
+                log: {};
+                fs: any;
+                watch: {
+                    mod: boolean;
+                    add: boolean;
+                    rem: boolean;
+                };
+            };
+        };
+        valid: <V_1>(root?: V_1 | undefined, ctx?: import("gubu").Context) => root is V_1 & {
+            spec: {
+                base: string;
+                path: string;
+                debug: string;
+                use: {};
+                res: never[];
+                require: string;
+                log: {};
+                fs: import("gubu").Node<unknown>;
+                watch: {
+                    mod: boolean;
+                    add: boolean;
+                    rem: boolean;
+                };
+            };
+        };
+        match(root?: any, ctx?: import("gubu").Context): boolean;
+        error(root?: any, ctx?: import("gubu").Context): {
+            gubu: boolean;
+            code: string;
+            gname: string;
+            props: ({
+                path: string;
+                type: string;
+                value: any;
+            }[]);
+            desc: () => ({
+                name: string;
+                code: string;
+                err: {
+                    key: string;
+                    type: string;
+                    node: import("gubu").Node<any>;
+                    value: any;
+                    path: string;
+                    why: string;
+                    check: string;
+                    args: Record<string, any>;
+                    mark: number;
+                    text: string;
+                    use: any;
+                }[];
+                ctx: any;
+            });
+            toJSON(): /*elided*/ any & {
+                err: any;
+                name: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+        }[];
+        spec(): any;
+        node(): import("gubu").Node<{
+            spec: {
+                base: string;
+                path: string;
+                debug: string;
+                use: {};
+                res: never[];
+                require: string;
+                log: {};
+                fs: import("gubu").Node<unknown>;
+                watch: {
+                    mod: boolean;
+                    add: boolean;
+                    rem: boolean;
+                };
+            };
+        }>;
+        stringify(...rest: any[]): string;
+        jsonify(): any;
+        toString(this: any): string;
+        gubu: {
+            gubu$: symbol;
+            v$: string;
+        };
+    };
+    match(root?: any, ctx?: import("gubu").Context): boolean;
+    error(root?: any, ctx?: import("gubu").Context): {
+        gubu: boolean;
+        code: string;
+        gname: string;
+        props: ({
+            path: string;
+            type: string;
+            value: any;
+        }[]);
+        desc: () => ({
+            name: string;
+            code: string;
+            err: {
+                key: string;
+                type: string;
+                node: import("gubu").Node<any>;
+                value: any;
+                path: string;
+                why: string;
+                check: string;
+                args: Record<string, any>;
+                mark: number;
+                text: string;
+                use: any;
+            }[];
+            ctx: any;
+        });
+        toJSON(): /*elided*/ any & {
+            err: any;
+            name: string;
+            message: string;
+        };
+        name: string;
+        message: string;
+        stack?: string;
+    }[];
+    spec(): any;
+    node(): import("gubu").Node<{
+        <V>(root?: V | undefined, ctx?: import("gubu").Context): V & {
+            spec: {
+                base: string;
+                path: string;
+                debug: string;
+                use: {};
+                res: never[];
+                require: string;
+                log: {};
+                fs: any;
+                watch: {
+                    mod: boolean;
+                    add: boolean;
+                    rem: boolean;
+                };
+            };
+        };
+        valid: <V>(root?: V | undefined, ctx?: import("gubu").Context) => root is V & {
+            spec: {
+                base: string;
+                path: string;
+                debug: string;
+                use: {};
+                res: never[];
+                require: string;
+                log: {};
+                fs: import("gubu").Node<unknown>;
+                watch: {
+                    mod: boolean;
+                    add: boolean;
+                    rem: boolean;
+                };
+            };
+        };
+        match(root?: any, ctx?: import("gubu").Context): boolean;
+        error(root?: any, ctx?: import("gubu").Context): {
+            gubu: boolean;
+            code: string;
+            gname: string;
+            props: ({
+                path: string;
+                type: string;
+                value: any;
+            }[]);
+            desc: () => ({
+                name: string;
+                code: string;
+                err: {
+                    key: string;
+                    type: string;
+                    node: import("gubu").Node<any>;
+                    value: any;
+                    path: string;
+                    why: string;
+                    check: string;
+                    args: Record<string, any>;
+                    mark: number;
+                    text: string;
+                    use: any;
+                }[];
+                ctx: any;
+            });
+            toJSON(): /*elided*/ any & {
+                err: any;
+                name: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+        }[];
+        spec(): any;
+        node(): import("gubu").Node<{
+            spec: {
+                base: string;
+                path: string;
+                debug: string;
+                use: {};
+                res: never[];
+                require: string;
+                log: {};
+                fs: import("gubu").Node<unknown>;
+                watch: {
+                    mod: boolean;
+                    add: boolean;
+                    rem: boolean;
+                };
+            };
+        }>;
+        stringify(...rest: any[]): string;
+        jsonify(): any;
+        toString(this: any): string;
+        gubu: {
+            gubu$: symbol;
+            v$: string;
+        };
+    }>;
+    stringify(...rest: any[]): string;
+    jsonify(): any;
+    toString(this: any): string;
+    gubu: {
+        gubu$: symbol;
+        v$: string;
+    };
+};
+type Build = ReturnType<typeof BuildShape>;
+type ApiModel = {
+    main: {
+        api: {
+            entity: Record<string, any>;
+        };
+        def: Record<string, any>;
+    };
+};
+export { OpenModelShape, OpenBuildShape, };
+export type { Log, FsUtil, ApiDefOptions, Model, Build, ApiModel, };

package/dist/types.js ADDED Viewed

@@ -0,0 +1,39 @@
+"use strict";
+/* Copyright (c) 2025 Voxgig, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenBuildShape = exports.OpenModelShape = void 0;
+const gubu_1 = require("gubu");
+const ModelShape = (0, gubu_1.Gubu)({
+    name: String,
+    def: String,
+    main: {
+        sdk: {},
+        def: {},
+        api: {
+            guide: {},
+            entity: {},
+        },
+    }
+});
+const OpenModelShape = (0, gubu_1.Gubu)((0, gubu_1.Open)(ModelShape), { name: 'Model' });
+exports.OpenModelShape = OpenModelShape;
+const BuildShape = (0, gubu_1.Gubu)({
+    spec: {
+        base: '',
+        path: '',
+        debug: '',
+        use: {},
+        res: [],
+        require: '',
+        log: {},
+        fs: (0, gubu_1.Any)(),
+        watch: {
+            mod: true,
+            add: true,
+            rem: true,
+        }
+    }
+});
+const OpenBuildShape = (0, gubu_1.Gubu)((0, gubu_1.Open)(BuildShape));
+exports.OpenBuildShape = OpenBuildShape;
+//# sourceMappingURL=types.js.map