@vorplex/core 0.0.8 → 0.0.11

package/dist/modules/tson/schemas/boolean.js

@@ -0,0 +1,38 @@
+import { TsonError } from '../error';
+import { TsonSchemaBase } from './schema-base';
+export class TsonBoolean extends TsonSchemaBase {
+    definition;
+    constructor(definition = {
+        type: 'boolean',
+    }) {
+        super();
+        this.definition = definition;
+    }
+    default(value) {
+        return new TsonBoolean({
+            ...this.definition,
+            default: value,
+        });
+    }
+    getDefault() {
+        return this.definition.default ?? false;
+    }
+    accepts(definition) {
+        if (definition == null)
+            return this.definition.default !== undefined;
+        if (definition.type === 'any')
+            return true;
+        if (definition.type !== 'boolean')
+            return false;
+        if (this.definition.default === undefined && definition.default !== undefined)
+            return false;
+        return true;
+    }
+    parse(value) {
+        if (this.parseDefault(value))
+            return this.definition.default;
+        if (value != null && typeof value !== 'boolean')
+            throw new TsonError('Boolean expected', value, this);
+        return value;
+    }
+}

package/dist/modules/tson/schemas/enum.d.ts

@@ -0,0 +1,15 @@
+import type { TsonDefinition } from '../schema';
+import { type TsonDefinitionBase, TsonSchemaBase } from './schema-base';
+export interface TsonEnumDefinition<T extends string | number = any> extends TsonDefinitionBase {
+    readonly type: 'enum';
+    default?: T;
+    flags: T[];
+}
+export declare class TsonEnum<T extends string | number = any> extends TsonSchemaBase<T> {
+    definition: TsonEnumDefinition<T>;
+    constructor(definition?: TsonEnumDefinition<T>);
+    default(value: any): TsonEnum;
+    getDefault(): T;
+    accepts(definition: TsonDefinition | null | undefined): boolean;
+    parse(value: any): T;
+}

package/dist/modules/tson/schemas/enum.js

@@ -0,0 +1,43 @@
+import { TsonError } from '../error';
+import { TsonSchemaBase } from './schema-base';
+export class TsonEnum extends TsonSchemaBase {
+    definition;
+    constructor(definition = {
+        type: 'enum',
+        flags: [],
+    }) {
+        super();
+        this.definition = definition;
+    }
+    default(value) {
+        return new TsonEnum({
+            ...this.definition,
+            default: value,
+        });
+    }
+    getDefault() {
+        return this.definition.default ?? this.definition.flags[0];
+    }
+    accepts(definition) {
+        if (definition.type === 'any')
+            return true;
+        if (definition == null && this.definition.default !== undefined)
+            return true;
+        if (this.definition.default === undefined && definition.default !== undefined)
+            return false;
+        if (definition.type !== 'enum')
+            return false;
+        return this.definition.flags.every((flag) => definition.flags.includes(flag));
+    }
+    parse(value) {
+        if (this.parseDefault(value))
+            return this.definition.default;
+        if (value != null && typeof this.definition.flags[0] === 'string' && typeof value !== 'string')
+            throw new TsonError('String expected', value, this);
+        if (value != null && typeof this.definition.flags[0] === 'number' && typeof value !== 'number')
+            throw new TsonError('Number expected', value, this);
+        if (!this.definition.flags.includes(value))
+            throw new TsonError('Invalid value', value, this);
+        return value;
+    }
+}

package/dist/modules/tson/schemas/number.d.ts

@@ -0,0 +1,20 @@
+import type { TsonDefinition } from '../schema';
+import { type TsonDefinitionBase, TsonSchemaBase } from './schema-base';
+export interface TsonNumberDefinition extends TsonDefinitionBase {
+    readonly type: 'number';
+    min?: number;
+    max?: number;
+    default?: number;
+    integer?: boolean;
+}
+export declare class TsonNumber extends TsonSchemaBase<number> {
+    definition: TsonNumberDefinition;
+    constructor(definition?: TsonNumberDefinition);
+    default(value: any): TsonNumber;
+    isInteger(): TsonNumber;
+    min(value: number): TsonNumber;
+    max(value: number): TsonNumber;
+    getDefault(): number;
+    accepts(definition: TsonDefinition | null | undefined): boolean;
+    parse(value: any): number;
+}

package/dist/modules/tson/schemas/number.js

@@ -0,0 +1,66 @@
+import { TsonError } from '../error';
+import { TsonSchemaBase } from './schema-base';
+export class TsonNumber extends TsonSchemaBase {
+    definition;
+    constructor(definition = {
+        type: 'number',
+    }) {
+        super();
+        this.definition = definition;
+    }
+    default(value) {
+        return new TsonNumber({
+            ...this.definition,
+            default: value,
+        });
+    }
+    isInteger() {
+        return new TsonNumber({
+            ...this.definition,
+            integer: true,
+        });
+    }
+    min(value) {
+        return new TsonNumber({
+            ...this.definition,
+            min: value,
+        });
+    }
+    max(value) {
+        return new TsonNumber({
+            ...this.definition,
+            max: value,
+        });
+    }
+    getDefault() {
+        return this.definition.default ?? 0;
+    }
+    accepts(definition) {
+        if (definition == null && this.definition.default !== undefined)
+            return true;
+        if (definition.type === 'any')
+            return true;
+        if (this.definition.default === undefined && definition.default !== undefined)
+            return false;
+        if (definition.type !== 'number')
+            return false;
+        if (this.definition.min != null && (definition.min == null || definition.min < this.definition.min))
+            return false;
+        if (this.definition.max != null && (definition.max == null || definition.max > this.definition.max))
+            return false;
+        if (this.definition.integer != null && this.definition.integer !== definition.integer)
+            return false;
+        return true;
+    }
+    parse(value) {
+        if (this.parseDefault(value))
+            return this.definition.default;
+        if (value != null && typeof value !== 'number')
+            throw new TsonError('Number expected', value, this);
+        if (this.definition.min != null && value < this.definition.min)
+            throw new TsonError(`Number should be greater than ${this.definition.min}`, value, this);
+        if (this.definition.max != null && value > this.definition.max)
+            throw new TsonError(`Number should be less than ${this.definition.max}`, value, this);
+        return value;
+    }
+}

package/dist/modules/tson/schemas/object.d.ts

@@ -0,0 +1,33 @@
+import type { Type } from '../../reflection/types/type.type';
+import type { TsonDefinition } from '../schema';
+import type { TsonType, TypeTson } from '../type';
+import { type TsonDefinitionBase, TsonSchemaBase } from './schema-base';
+export interface TsonObjectDefinition<T extends Record<string, any> = Record<string, any>> extends TsonDefinitionBase {
+    readonly type: 'object';
+    property?: TsonDefinition;
+    properties?: {
+        [key in keyof T]: TypeTson<T[key]>;
+    };
+    prototype?: any;
+    default?: T;
+}
+export declare class TsonObject<T extends {
+    [key: string]: TsonDefinition;
+} = {}> extends TsonSchemaBase<{
+    [P in keyof T]: TsonType<T[P]>;
+}> {
+    definition: TsonObjectDefinition<{
+        [P in keyof T]: TsonType<T[P]>;
+    }>;
+    constructor(definition?: TsonObjectDefinition<{
+        [P in keyof T]: TsonType<T[P]>;
+    }>);
+    getDefault(): {
+        [P in keyof T]: TsonType<T[P]>;
+    };
+    prototype(type: Type): TsonObject<T>;
+    accepts(definition: TsonDefinition | null | undefined): boolean;
+    parse(value: any): {
+        [P in keyof T]: TsonType<T[P]>;
+    };
+}

package/dist/modules/tson/schemas/object.js

@@ -0,0 +1,88 @@
+import { $Reflection } from '../../reflection/utils/reflection.util';
+import { TsonError } from '../error';
+import { $Tson } from '../tson';
+import { TsonSchemaBase } from './schema-base';
+export class TsonObject extends TsonSchemaBase {
+    definition;
+    constructor(definition = { type: 'object' }) {
+        super();
+        this.definition = definition;
+    }
+    getDefault() {
+        if (this.definition.default !== undefined)
+            return this.definition.default;
+        if (this.definition.property)
+            return {};
+        if (!this.definition.properties)
+            return {};
+        const result = {};
+        for (const property in this.definition.properties) {
+            result[property] = $Tson.parse(this.definition.properties[property]).getDefault();
+        }
+        return result;
+    }
+    prototype(type) {
+        this.definition.prototype = type.prototype;
+        return this;
+    }
+    accepts(definition) {
+        if (definition == null && this.definition.default !== undefined)
+            return true;
+        if (definition.type === 'any')
+            return true;
+        if (this.definition.default === undefined && definition.default !== undefined)
+            return false;
+        if (definition.type !== 'object')
+            return false;
+        if (this.definition.prototype != null && !$Reflection.extends(definition.prototype, this.definition.prototype))
+            return false;
+        if (this.definition.property) {
+            if (!definition.property)
+                return false;
+            if (!$Tson.parse(this.definition.property).accepts(definition.property))
+                return false;
+        }
+        if (this.definition.properties) {
+            for (const property in this.definition.properties) {
+                if (!$Tson.parse(this.definition.properties[property]).accepts(definition.properties?.[property]))
+                    return false;
+            }
+        }
+        return true;
+    }
+    parse(value) {
+        if (this.parseDefault(value))
+            return this.definition.default;
+        if (value != null && typeof value !== 'object')
+            throw new TsonError('Object expected', value, this);
+        if (this.definition.property) {
+            for (const property in value) {
+                try {
+                    value[property] = $Tson.parse(this.definition.property).parse(value[property]);
+                }
+                catch (error) {
+                    if (error instanceof TsonError) {
+                        error.path = `.${property}${error.path}`;
+                    }
+                    throw error;
+                }
+            }
+        }
+        if (this.definition.properties) {
+            for (const property in this.definition.properties) {
+                try {
+                    value[property] = $Tson.parse(this.definition.properties[property]).parse(value[property]);
+                }
+                catch (error) {
+                    if (error instanceof TsonError) {
+                        error.path = `.${property}${error.path}`;
+                    }
+                    throw error;
+                }
+            }
+        }
+        if (this.definition.prototype)
+            value = Object.setPrototypeOf(value, this.definition.prototype);
+        return value;
+    }
+}

package/dist/modules/tson/schemas/schema-base.d.ts

@@ -0,0 +1,12 @@
+export interface TsonDefinitionBase<T = any> {
+    readonly type: string;
+    default?: T;
+    description?: string;
+}
+export declare abstract class TsonSchemaBase<T = any> {
+    definition: TsonDefinitionBase<T>;
+    protected parseDefault(value: any): boolean;
+    abstract accepts(tson: TsonDefinitionBase | null | undefined): boolean;
+    abstract parse(value: any): T;
+    abstract getDefault(): T;
+}

package/dist/modules/tson/schemas/schema-base.js

@@ -0,0 +1,14 @@
+import { $String } from '../../string/string.util';
+import { TsonError } from '../error';
+export class TsonSchemaBase {
+    definition;
+    parseDefault(value) {
+        if (value == null) {
+            if (this.definition.default === undefined)
+                throw new TsonError(`${$String.upperCaseFirst(this.definition.type)} required`, value, this);
+            else
+                return true;
+        }
+        return false;
+    }
+}

package/dist/modules/tson/schemas/string.d.ts

@@ -0,0 +1,19 @@
+import type { TsonDefinition } from '../schema';
+import { type TsonDefinitionBase, TsonSchemaBase } from './schema-base';
+export interface TsonStringDefinition extends TsonDefinitionBase {
+    readonly type: 'string';
+    default?: string;
+    min?: number;
+    max?: number;
+    match?: string;
+}
+export declare class TsonString extends TsonSchemaBase<string> {
+    definition: TsonStringDefinition;
+    constructor(definition?: TsonStringDefinition);
+    match(regex: string): TsonString;
+    minLength(length: number): TsonString;
+    maxLength(length: number): TsonString;
+    getDefault(): string;
+    accepts(definition: TsonDefinition | null | undefined): boolean;
+    parse(value: any): string;
+}

package/dist/modules/tson/schemas/string.js

@@ -0,0 +1,60 @@
+import { TsonError } from '../error';
+import { TsonSchemaBase } from './schema-base';
+export class TsonString extends TsonSchemaBase {
+    definition;
+    constructor(definition = { type: 'string' }) {
+        super();
+        this.definition = definition;
+    }
+    match(regex) {
+        return new TsonString({
+            ...this.definition,
+            match: regex,
+        });
+    }
+    minLength(length) {
+        return new TsonString({
+            ...this.definition,
+            min: length,
+        });
+    }
+    maxLength(length) {
+        return new TsonString({
+            ...this.definition,
+            max: length,
+        });
+    }
+    getDefault() {
+        return this.definition.default ?? '';
+    }
+    accepts(definition) {
+        if (definition == null && this.definition.default !== undefined)
+            return true;
+        if (definition.type === 'any')
+            return true;
+        if (this.definition.default === undefined && definition.default !== undefined)
+            return false;
+        if (definition.type !== 'string')
+            return false;
+        if (this.definition.max != null && (definition.max == null || definition.max > this.definition.max))
+            return false;
+        if (this.definition.min != null && (definition.min == null || definition.min < this.definition.min))
+            return false;
+        if (this.definition.match != null && this.definition.match !== definition.match)
+            return false;
+        return true;
+    }
+    parse(value) {
+        if (this.parseDefault(value))
+            return this.definition.default;
+        if (value != null && typeof value !== 'string')
+            throw new TsonError('String expected', value, this);
+        if (this.definition.min != null && value.length < this.definition.min)
+            throw new TsonError(`Value min length of ${this.definition.min} expected`, value, this);
+        if (this.definition.max != null && value.length > this.definition.max)
+            throw new TsonError(`Value max length of ${this.definition.max} expected`, value, this);
+        if (this.definition.match != null && !new RegExp(this.definition.match).exec(value))
+            throw new TsonError(`Invalid value`, value, this);
+        return value;
+    }
+}

package/dist/modules/tson/schemas/union.d.ts

@@ -0,0 +1,16 @@
+import type { TsonDefinition } from '../schema';
+import type { TypeTson } from '../type';
+import { type TsonDefinitionBase, TsonSchemaBase } from './schema-base';
+export interface TsonUnionDefinition<T extends readonly any[] = any> extends TsonDefinitionBase<T> {
+    type: 'union';
+    default?: undefined;
+    union: readonly TypeTson<T>[];
+}
+export declare class TsonUnion<T = any> extends TsonSchemaBase<T> {
+    definition: TsonUnionDefinition;
+    constructor(definition?: TsonUnionDefinition);
+    default(value: any): TsonUnion;
+    getDefault(): undefined;
+    accepts(definition: TsonDefinition | null | undefined): boolean;
+    parse(value: any): any;
+}

package/dist/modules/tson/schemas/union.js

@@ -0,0 +1,56 @@
+import { TsonError } from '../error';
+import { $Tson } from '../tson';
+import { TsonSchemaBase } from './schema-base';
+export class TsonUnion extends TsonSchemaBase {
+    definition;
+    constructor(definition = {
+        type: 'union',
+        union: [],
+    }) {
+        super();
+        this.definition = definition;
+    }
+    default(value) {
+        return new TsonUnion({
+            ...this.definition,
+            default: value,
+        });
+    }
+    getDefault() {
+        return this.definition.default;
+    }
+    accepts(definition) {
+        if (definition == null && this.definition.default !== undefined)
+            return true;
+        if (definition.type === 'any')
+            return true;
+        if (definition.type !== 'union') {
+            for (const union of this.definition.union) {
+                if ($Tson.parse(union).accepts(definition))
+                    return true;
+            }
+            return false;
+        }
+        else {
+            for (const union2 of definition.union) {
+                if (!this.definition.union.some((union) => $Tson.parse(union).accepts(union2)))
+                    return false;
+            }
+            return true;
+        }
+    }
+    parse(value) {
+        if (this.parseDefault(value))
+            return this.definition.default;
+        for (const type of this.definition.union) {
+            try {
+                return $Tson.parse(type).parse(value);
+            }
+            catch (error) {
+                if (!(error instanceof TsonError))
+                    throw error;
+            }
+        }
+        throw new TsonError(`Union type mismatch`, value, this);
+    }
+}

package/dist/modules/tson/tson.d.ts

@@ -0,0 +1,41 @@
+import type { TsonDefinition, TsonSchema } from './schema';
+import { type TsonAnyDefinition } from './schemas/any';
+import { type TsonArrayDefinition } from './schemas/array';
+import { type TsonBooleanDefinition } from './schemas/boolean';
+import { type TsonEnumDefinition } from './schemas/enum';
+import { type TsonNumberDefinition } from './schemas/number';
+import { type TsonObjectDefinition } from './schemas/object';
+import { type TsonStringDefinition } from './schemas/string';
+import { type TsonUnionDefinition } from './schemas/union';
+export declare class $Tson {
+    static string<T extends Omit<TsonStringDefinition, 'type'>>(definition?: T): T & Pick<TsonStringDefinition, 'type'>;
+    static number<T extends Omit<TsonNumberDefinition, 'type'>>(definition?: T): T & Pick<TsonNumberDefinition, 'type'>;
+    static boolean<T extends Omit<TsonBooleanDefinition, 'type'>>(definition?: T): T & Pick<TsonBooleanDefinition, 'type'>;
+    static array<T extends Omit<TsonArrayDefinition, 'type'>>(definition?: T): T & Pick<TsonArrayDefinition, 'type'>;
+    static object<P extends Record<string, TsonDefinition>>(definition: {
+        properties: P;
+    } & Omit<TsonObjectDefinition<P>, 'type' | 'properties'>): {
+        readonly type: 'object';
+        properties: P;
+    };
+    static object<P extends TsonDefinition>(definition: {
+        property: P;
+    } & Omit<TsonObjectDefinition<P>, 'type' | 'property'>): {
+        readonly type: 'object';
+        property: P;
+    };
+    static object<T>(definition?: Omit<TsonObjectDefinition<T>, 'type'>): TsonObjectDefinition<T>;
+    static any(definition?: Omit<TsonAnyDefinition, 'type'>): TsonAnyDefinition;
+    static enum<T extends string | number = any>(definition?: Omit<TsonEnumDefinition<T>, 'type'>): TsonEnumDefinition<T>;
+    static const<T extends string | number>(...flags: T[]): TsonEnumDefinition<T>;
+    static union<T extends readonly TsonDefinition[]>(definition: {
+        union: T;
+    } & Omit<TsonUnionDefinition<T>, 'union' | 'type'>): {
+        type: 'union';
+        union: T;
+    };
+    static fromEnum<T extends object>(flags: T): TsonEnumDefinition<T[keyof T] extends string ? T[keyof T] & string : T[keyof T] & number>;
+    static parse(definition: TsonDefinition): TsonSchema;
+    static generateTypeScriptDefinition(definition: TsonDefinition): string;
+    static generate(value: any): TsonDefinition;
+}

package/dist/modules/tson/tson.js

@@ -0,0 +1,138 @@
+import { $Enum } from '../enum/enum.util';
+import { $Reflection } from '../reflection/utils/reflection.util';
+import { $String } from '../string/string.util';
+import { TsonAny } from './schemas/any';
+import { TsonArray } from './schemas/array';
+import { TsonBoolean } from './schemas/boolean';
+import { TsonEnum } from './schemas/enum';
+import { TsonNumber } from './schemas/number';
+import { TsonObject } from './schemas/object';
+import { TsonString } from './schemas/string';
+import { TsonUnion } from './schemas/union';
+export class $Tson {
+    static string(definition) {
+        return { type: 'string', ...(definition ?? {}) };
+    }
+    static number(definition) {
+        return { type: 'number', ...(definition ?? {}) };
+    }
+    static boolean(definition) {
+        return { type: 'boolean', ...(definition ?? {}) };
+    }
+    static array(definition) {
+        return { type: 'array', ...(definition ?? {}) };
+    }
+    static object(definition) {
+        return { type: 'object', ...(definition ?? {}) };
+    }
+    static any(definition) {
+        return { type: 'any', ...(definition ?? {}) };
+    }
+    static enum(definition) {
+        return { type: 'enum', flags: [], ...(definition ?? {}) };
+    }
+    static const(...flags) {
+        return {
+            type: 'enum',
+            flags
+        };
+    }
+    static union(definition) {
+        return {
+            type: 'union',
+            union: [],
+            ...(definition ?? {}),
+        };
+    }
+    static fromEnum(flags) {
+        return {
+            type: 'enum',
+            flags: $Enum.getValues(flags),
+        };
+    }
+    static parse(definition) {
+        switch (definition.type) {
+            case 'any':
+                return new TsonAny(definition);
+            case 'string':
+                return new TsonString(definition);
+            case 'number':
+                return new TsonNumber(definition);
+            case 'boolean':
+                return new TsonBoolean(definition);
+            case 'object':
+                return new TsonObject(definition);
+            case 'array':
+                return new TsonArray(definition);
+            case 'enum':
+                return new TsonEnum(definition);
+            case 'union':
+                return new TsonUnion(definition);
+        }
+    }
+    static generateTypeScriptDefinition(definition) {
+        if (definition == null)
+            return 'any';
+        switch (definition.type) {
+            case 'any':
+                return 'any';
+            case 'string':
+                return 'string';
+            case 'number':
+                return 'number';
+            case 'boolean':
+                return 'boolean';
+            case 'object':
+                if (definition.property) {
+                    let result = '';
+                    if (definition.description)
+                        result += `// ${definition.property.description}\n`;
+                    result += `[key: string]: ${this.generateTypeScriptDefinition(definition.property)}`;
+                    return `{\n${$String.indent(result, 4)}\n}`;
+                }
+                else if (definition.properties) {
+                    const result = Object
+                        .entries(definition.properties)
+                        .map(([property, value]) => {
+                        let result = '';
+                        if (value.description)
+                            result += `// ${value.description}\n`;
+                        result += `'${property}'${'default' in value ? '?' : ''}: ${this.generateTypeScriptDefinition(value)}`;
+                        return result;
+                    })
+                        .join(',\n');
+                    return `{\n${$String.indent(result, 4)}\n}`;
+                }
+                else
+                    return 'Record<string, any>';
+            case 'array':
+                return `${this.generateTypeScriptDefinition(definition.itemDefinition)}[]`;
+            case 'enum':
+                return `${definition.flags.map(flag => typeof flag === 'string' ? `'${flag}'` : flag).join(' | ')}`;
+            case 'union':
+                return `${definition.union.map(definition => this.generateTypeScriptDefinition(definition)).join(' | ')}`;
+        }
+    }
+    static generate(value) {
+        if (typeof value === 'string')
+            return $Tson.string();
+        if (typeof value === 'number')
+            return $Tson.number();
+        if (typeof value === 'boolean')
+            return $Tson.boolean();
+        if ($Enum.isEnum(value))
+            return $Tson.enum(value);
+        if ($Reflection.isArray(value))
+            return $Tson.array({
+                itemDefinition: $Tson.generate(value[0]) ?? $Tson.any(),
+            });
+        if ($Reflection.isObject(value))
+            return $Tson.object({
+                properties: Object.keys(value).reduce((properties, key) => ({
+                    ...properties,
+                    [key]: $Tson.generate(value[key]),
+                }), {}),
+            });
+        return $Tson.any();
+    }
+}