@based/schema 4.1.1 → 5.0.0-alpha.1

package/dist/src/walker/args.js

@@ -1,158 +0,0 @@
-import { Stopped } from './types.js';
-import { parse } from './parse.js';
-import { deepEqual } from '@saulx/utils';
-let id = 0;
-export class ArgsClass {
-    constructor(opts, prev) {
-        this.id = ++id;
-        this.fromBackTrack = [];
-        this.collectedCommands = [];
-        if (opts.prev) {
-            prev = opts.prev;
-        }
-        if (opts.parseTopLevel) {
-            this.parseTopLevel = opts.parseTopLevel;
-        }
-        if (prev) {
-            this.prev = prev;
-            this.root = prev.root;
-            this.fieldSchema = prev.fieldSchema;
-        }
-        if (opts.path) {
-            this.path = opts.path;
-        }
-        else if (prev && opts.key !== undefined) {
-            this.path = [...prev.path, opts.key];
-        }
-        else if (opts && prev) {
-            this.path = prev.path;
-        }
-        else {
-            this.path = [];
-        }
-        this.value = opts.value;
-        if (opts.fieldSchema) {
-            // @ts-ignore K is too loose
-            this.fieldSchema = opts.fieldSchema;
-        }
-        if (opts.typeSchema) {
-            this.typeSchema = opts.typeSchema;
-        }
-        if (opts.target) {
-            this._target = opts.target;
-        }
-        if (opts.collect) {
-            this._collectOverride = opts.collect;
-        }
-        else if (prev?._collectOverride) {
-            this._collectOverride = prev._collectOverride;
-        }
-        if (opts.skipCollection) {
-            this.skipCollection = opts.skipCollection;
-        }
-        else if (prev?.skipCollection) {
-            this.skipCollection = true;
-        }
-    }
-    get schema() {
-        if (this._schema) {
-            return this.schema;
-        }
-        return this.root._schema;
-    }
-    get key() {
-        return this.path[this.path.length - 1] ?? '';
-    }
-    get target() {
-        if (this._target) {
-            return this._target;
-        }
-        let p = this.prev;
-        while (p) {
-            if (p._target) {
-                return p._target;
-            }
-            p = p.prev;
-        }
-    }
-    stop(onllyStopFieldSchemaParser) {
-        const target = this;
-        if (onllyStopFieldSchemaParser) {
-            target.stopped = Stopped.onlyStopFieldParser;
-        }
-        else {
-            target.stopped = Stopped.stopAll;
-        }
-    }
-    create(opts) {
-        const newArgs = new ArgsClass(opts, this);
-        if (this._collectOverride && !opts.collect) {
-            newArgs._collectOverride = this._collectOverride;
-        }
-        if (this.skipCollection && opts.skipCollection !== false) {
-            newArgs.skipCollection = this.skipCollection;
-        }
-        if (!('value' in opts)) {
-            newArgs.value = this.value;
-        }
-        return newArgs;
-    }
-    async parse(opts) {
-        if (!opts) {
-            return parse(this);
-        }
-        else {
-            const newArgs = new ArgsClass(opts, this);
-            if (newArgs.value === undefined) {
-                newArgs.value = this.value;
-            }
-            return newArgs.parse();
-        }
-    }
-    getTopPaths() {
-        let argPath = [];
-        let p = this;
-        while (p) {
-            argPath.unshift({ path: p.path, id: p.id });
-            // @ts-ignore
-            p = p.prev;
-        }
-        return argPath;
-    }
-    getBackTrackTarget() {
-        let p = this;
-        while (p) {
-            if (p.prev) {
-                if (deepEqual(p.prev.path, p.path)) {
-                    p = p.prev;
-                }
-                else {
-                    p = p.prev;
-                    break;
-                }
-            }
-            else {
-                break;
-            }
-        }
-        return p;
-    }
-    getCollectTarget() { }
-    collect(value) {
-        if (this.skipCollection) {
-            return;
-        }
-        const collectArgs = value !== undefined ? new ArgsClass({ value }, this) : this;
-        let collectTarget = this.prev;
-        if (this._collectOverride) {
-            collectTarget.collectedCommands.push(this._collectOverride(collectArgs));
-        }
-        else {
-            collectTarget.collectedCommands.push(this.root._opts.collect(collectArgs));
-        }
-    }
-    error(code) {
-        this.root._opts.error(code, this);
-    }
-}
-//# sourceMappingURL=args.js.map

package/dist/src/walker/index.d.ts

@@ -1,6 +0,0 @@
-import { BasedSchema } from '../types.js';
-import { ArgsClass } from './args.js';
-import { AsyncOperation, Opts } from './types.js';
-export declare const walk: <T>(schema: BasedSchema, opts: Opts<T>, value: any, asyncOperationHandler?: AsyncOperation<T>) => Promise<T>;
-export { ArgsClass };
-export * from './types.js';

package/dist/src/walker/index.js

@@ -1,31 +0,0 @@
-import { ArgsClass } from './args.js';
-export const walk = async (schema, opts, value, asyncOperationHandler) => {
-    if (!('collect' in opts)) {
-        opts.collect = () => { };
-    }
-    if (!('error' in opts)) {
-        opts.error = () => { };
-    }
-    if (asyncOperationHandler) {
-        opts = {
-            ...opts,
-            asyncOperationHandler,
-        };
-    }
-    const argsOpts = await opts.init(value, schema, opts.error);
-    if (!argsOpts) {
-        return {};
-    }
-    if (!argsOpts.value) {
-        argsOpts.value = value;
-    }
-    const args = new ArgsClass(argsOpts);
-    args.root = args;
-    args._opts = opts;
-    args._schema = schema;
-    await args.parse();
-    return args.target;
-};
-export { ArgsClass };
-export * from './types.js';
-//# sourceMappingURL=index.js.map

package/dist/src/walker/parse.d.ts

@@ -1,3 +0,0 @@
-import { ArgsClass } from './args.js';
-export type ParseResult<T> = ArgsClass<T> | void;
-export declare function parse<T>(args: ArgsClass<T>): Promise<ArgsClass<T> | void>;

package/dist/src/walker/parse.js

@@ -1,182 +0,0 @@
-import { ArgsClass } from './args.js';
-import { Stopped } from './types.js';
-// TODO needs cleaning
-function createOrUseArgs(from, newArgs) {
-    if (!newArgs) {
-        return;
-    }
-    if (newArgs instanceof ArgsClass) {
-        return newArgs;
-    }
-    const x = from.create(newArgs);
-    // x.collectedCommands = from.collectedCommands
-    // x.fromBackTrack = from.fromBackTrack
-    return x;
-}
-async function parseKey(from, key, parser) {
-    const keyArgs = new ArgsClass({
-        key,
-        value: from.value[key],
-        fieldSchema: from.fieldSchema,
-    }, from);
-    // if same
-    const newArgs = createOrUseArgs(keyArgs, await parser(keyArgs));
-    if (newArgs) {
-        return newArgs.parse();
-    }
-}
-function createFieldArgs(from, key, fieldSchema) {
-    return new ArgsClass({
-        key,
-        value: from.value[key],
-        // @ts-ignore needs key
-        fieldSchema,
-    }, from);
-}
-function getFieldParser(args) {
-    const fieldParser = 'enum' in args.fieldSchema
-        ? args.root._opts.parsers.fields.enum
-        : args.root._opts.parsers.fields[args.fieldSchema.type];
-    return fieldParser;
-}
-export async function parse(args) {
-    const opts = args.root._opts;
-    if (args.parseTopLevel) {
-        const parser = opts.parsers.any;
-        if (parser) {
-            const nArgs = await parser(args);
-            if (nArgs) {
-                // @ts-ignore
-                return parse(createOrUseArgs(args, nArgs));
-            }
-        }
-    }
-    if (typeof args.value === 'object' && args.value !== null) {
-        const keyQ = [];
-        const keysHandled = new Set();
-        let allKeysHandled = false;
-        for (const key in opts.parsers.keys) {
-            if (key in args.value) {
-                keysHandled.add(key);
-                keyQ.push(parseKey(args, key, opts.parsers.keys[key]));
-            }
-        }
-        await Promise.all(keyQ);
-        if (typeof args.value !== 'object' || args.value === null) {
-            return;
-        }
-        // schema
-        if (args.stopped === undefined) {
-            const fieldQ = [];
-            if (args.typeSchema && !args.fieldSchema) {
-                for (const key in args.typeSchema.fields) {
-                    const fieldSchema = args.typeSchema.fields[key];
-                    if (key in args.value) {
-                        keysHandled.add(key);
-                        fieldQ.push(createFieldArgs(args, key, fieldSchema).parse());
-                    }
-                }
-            }
-            else if (args.fieldSchema && !args.stopped) {
-                if (args.fieldSchema.type === 'object') {
-                    // @ts-ignore should detect from line above
-                    const objFieldSchema = args.fieldSchema;
-                    for (const key in objFieldSchema.properties) {
-                        const fieldSchema = objFieldSchema.properties[key];
-                        if (key in args.value) {
-                            keysHandled.add(key);
-                            fieldQ.push(createFieldArgs(args, key, fieldSchema).parse());
-                        }
-                    }
-                }
-                else if (args.fieldSchema.type === 'record') {
-                    // @ts-ignore should detect from line above
-                    const objFieldSchema = args.fieldSchema;
-                    for (const key in args.value) {
-                        const fieldSchema = objFieldSchema.values;
-                        keysHandled.add(key);
-                        fieldQ.push(createFieldArgs(args, key, fieldSchema).parse());
-                    }
-                }
-                else if (args.fieldSchema) {
-                    const fieldParser = getFieldParser(args);
-                    if (fieldParser) {
-                        const newArgs = createOrUseArgs(args, await fieldParser(args));
-                        if (newArgs) {
-                            return newArgs.parse();
-                        }
-                    }
-                }
-            }
-            await Promise.all(fieldQ);
-            if (args.fieldSchema &&
-                fieldQ.length > 0 &&
-                (args.fieldSchema.type === 'object' ||
-                    args.fieldSchema.type === 'record')) {
-                const fieldParser = getFieldParser(args);
-                if (fieldParser) {
-                    fieldParser(args);
-                }
-            }
-        }
-        if (typeof args.value !== 'object' || args.value === null) {
-            return;
-        }
-        // any
-        if (args.stopped !== Stopped.stopAll) {
-            const parser = opts.parsers.any || opts.parsers.catch;
-            if (parser) {
-                const q = [];
-                if (Array.isArray(args.value)) {
-                    for (let i = 0; i < args.value.length; i++) {
-                        if ((!opts.parsers.any && keysHandled.has(i)) || allKeysHandled) {
-                            continue;
-                        }
-                        q.push(parseKey(args, i, parser));
-                    }
-                }
-                else {
-                    for (const key in args.value) {
-                        if ((!opts.parsers.any && keysHandled.has(key)) || allKeysHandled) {
-                            continue;
-                        }
-                        q.push(parseKey(args, key, parser));
-                    }
-                }
-                await Promise.all(q);
-            }
-        }
-        if (opts.backtrack &&
-            !args.skipCollection &&
-            (args.fromBackTrack.length || args.collectedCommands.length)) {
-            const backtracked = opts.backtrack(args, args.fromBackTrack ?? [], args.collectedCommands ?? []);
-            if (backtracked) {
-                const target = args.getBackTrackTarget();
-                if (!target.fromBackTrack) {
-                    target.fromBackTrack = [];
-                }
-                target.fromBackTrack.push(backtracked);
-            }
-        }
-    }
-    else {
-        // more
-        if (args.fieldSchema) {
-            const fieldParser = getFieldParser(args);
-            if (fieldParser) {
-                const newArgs = createOrUseArgs(args, await fieldParser(args));
-                if (newArgs) {
-                    return newArgs.parse();
-                }
-            }
-            else {
-                console.warn('fieldSchema type not implemented yet!', args.fieldSchema);
-                const anyParser = opts.parsers.any || opts.parsers.catch;
-                anyParser(args);
-            }
-        }
-        else {
-        }
-    }
-}
-//# sourceMappingURL=parse.js.map

package/dist/src/walker/types.d.ts

@@ -1,45 +0,0 @@
-import { ParseError } from '../error.js';
-import { BasedSchemaType, BasedSchemaFields, BasedSchemaField, BasedSchema } from '../types.js';
-import { ArgsClass } from './args.js';
-export type Path = (string | number)[];
-export type ErrorHandler<T> = (code: ParseError, args: ArgsClass<T> | ArgsOpts<T>) => void;
-export type Collect<T> = (args: ArgsClass<T>) => any;
-export type FieldParser<K extends keyof BasedSchemaFields, T = any> = (args: ArgsClass<T, K>) => Promise<ArgsClass<T> | ArgsOpts<T> | void>;
-export type KeyParser<T = any> = (args: ArgsClass<T, keyof BasedSchemaFields>) => Promise<ArgsOpts<T> | ArgsClass<T> | void>;
-export type FieldParsers<T = any> = {
-    [Key in keyof BasedSchemaFields]: FieldParser<Key, T>;
-};
-export type AsyncOperation<T> = (args: ArgsClass<T>, type?: string) => Promise<any>;
-export type Opts<T> = {
-    init: (value: any, schema: BasedSchema, error: ErrorHandler<T>) => Promise<ArgsOpts<T>>;
-    parsers: {
-        fields: Partial<{
-            [Key in keyof BasedSchemaFields]: FieldParser<Key, T>;
-        }>;
-        keys: {
-            [key: string]: KeyParser<T>;
-        };
-        any?: KeyParser<T>;
-        catch?: KeyParser<T>;
-    };
-    collect?: (args: ArgsClass<T>) => any;
-    error?: ErrorHandler<T>;
-    backtrack?: (args: ArgsClass<T>, fromBackTrack: any[], collectedCommands: any[]) => any;
-    asyncOperationHandler?: AsyncOperation<T>;
-};
-export declare enum Stopped {
-    onlyStopFieldParser = 0,
-    stopAll = 1
-}
-export type ArgsOpts<T, K extends keyof BasedSchemaFields = keyof BasedSchemaFields> = {
-    parseTopLevel?: boolean;
-    target?: T;
-    key?: string | number;
-    path?: Path;
-    value?: any;
-    prev?: ArgsClass<T, K>;
-    fieldSchema?: BasedSchemaField;
-    typeSchema?: BasedSchemaType;
-    skipCollection?: boolean;
-    collect?: (args: ArgsClass<T, K>, value?: any) => any;
-};

package/dist/src/walker/types.js

@@ -1,7 +0,0 @@
-export var Stopped;
-(function (Stopped) {
-    Stopped[Stopped["onlyStopFieldParser"] = 0] = "onlyStopFieldParser";
-    Stopped[Stopped["stopAll"] = 1] = "stopAll";
-})(Stopped || (Stopped = {}));
-// Add asyncOperations // requiresAsyncValidation -> asyncOperation: () => {}
-//# sourceMappingURL=types.js.map

package/dist/test/array.d.ts

@@ -1 +0,0 @@
-export {};