affinirum 1.0.0

package/dst/Type.js

@@ -0,0 +1,196 @@
+import { PrimitiveAtom } from './atom/PrimitiveAtom.js';
+import { ArrayAtom } from './atom/ArrayAtom.js';
+import { ObjectAtom } from './atom/ObjectAtom.js';
+import { FunctionAtom } from './atom/FunctionAtom.js';
+export class Type {
+    _atoms;
+    constructor(_atoms = []) {
+        this._atoms = _atoms;
+    }
+    get isUnknown() {
+        return this._atoms.length === 0;
+    }
+    get isAtom() {
+        return this._atoms.length === 1;
+    }
+    get isOptional() {
+        return this.isUnknown || this._atoms.length > 1 && this._atoms.some((i) => i.match(Type.Void._atoms[0]));
+    }
+    get isVoid() {
+        return this.isAtom && this._atoms[0].match(Type.Void._atoms[0]);
+    }
+    get isBoolean() {
+        return this.isAtom && this._atoms[0].match(Type.Boolean._atoms[0]);
+    }
+    get isTimestamp() {
+        return this.isAtom && this._atoms[0].match(Type.Timestamp._atoms[0]);
+    }
+    get isFloat() {
+        return this.isAtom && this._atoms[0].match(Type.Float._atoms[0]);
+    }
+    get isInteger() {
+        return this.isAtom && this._atoms[0].match(Type.Integer._atoms[0]);
+    }
+    get isBuffer() {
+        return this.isAtom && this._atoms[0].match(Type.Buffer._atoms[0]);
+    }
+    get isString() {
+        return this.isAtom && this._atoms[0].match(Type.String._atoms[0]);
+    }
+    get isArray() {
+        return this._atoms.every((i) => i instanceof ArrayAtom);
+    }
+    get isObject() {
+        return this._atoms.every((i) => i instanceof ObjectAtom);
+    }
+    get isFunction() {
+        return this._atoms.every((i) => i instanceof FunctionAtom);
+    }
+    get isNumeric() {
+        return this._atoms.length === 2
+            && (this._atoms[0].match(Type.Float._atoms[0]) || this._atoms[0].match(Type.Integer._atoms[0]));
+    }
+    toOptional() {
+        return this._atoms.length ? Type.union(Type.Void, this) : this;
+    }
+    mergeFunctionAtomRetType(type) {
+        const atoms = this._atoms.filter((i) => i instanceof FunctionAtom && (!i.retType || i.retType.match(type)));
+        return Type.union(...atoms.map((i) => i.retType ?? Type.Unknown));
+    }
+    mergeFunctionAtom(type, argc) {
+        if (this.isUnknown || type.isVoid) {
+            return Type._functionAtom(type, Array.from({ length: argc }).map(() => Type.Unknown), false);
+        }
+        const atoms = this._atoms.filter((i) => i instanceof FunctionAtom && i.minArity <= argc && i.maxArity >= argc && (!i.retType || i.retType.match(type)));
+        if (!atoms.length) {
+            return undefined;
+        }
+        return Type._functionAtom(Type.union(...atoms.map((i) => i.retType ?? Type.Unknown)), Array.from({ length: argc }).map((_, ix) => Type.union(...atoms.map((i) => i.argType(ix)))), atoms.some((i) => i.isVariadic));
+    }
+    reduce(mask) {
+        if (mask.isUnknown || mask.isVoid) {
+            return this;
+        }
+        if (this.isUnknown) {
+            return mask;
+        }
+        const list = this._atoms.filter((i) => mask.match(i));
+        return list.length === 0
+            ? undefined
+            : list.length === this._atoms.length
+                ? this
+                : new Type(list);
+    }
+    match(type) {
+        if (type instanceof Type) {
+            return this.isUnknown || type.isUnknown || type.isVoid || this._atoms.some((i) => type._atoms.some((j) => i.match(j)));
+        }
+        else {
+            return this._atoms.some((i) => i.match(type));
+        }
+    }
+    weight() {
+        return this._atoms.reduce((acc, i) => acc + i.weight(), 0);
+    }
+    toString() {
+        return this._atoms.length
+            ? this._atoms.sort((a, b) => a.weight() - b.weight()).map((i) => i.toString()).join('|')
+            : '??';
+    }
+    static union(...types) {
+        if (types.some((i) => i.isUnknown)) {
+            return Type.Unknown;
+        }
+        const type = new Type([]);
+        types.map((i) => i._atoms).flat().forEach((i) => {
+            if (!type.match(i)) {
+                type._atoms.push(i);
+            }
+        });
+        return type;
+    }
+    static of(value) {
+        return value == null
+            ? Type.Void
+            : typeof value === 'boolean'
+                ? Type.Boolean
+                : value instanceof Date
+                    ? Type.Timestamp
+                    : typeof value === 'number'
+                        ? Type.Float
+                        : typeof value === 'bigint'
+                            ? Type.Integer
+                            : value instanceof ArrayBuffer
+                                ? Type.Buffer
+                                : typeof value === 'string'
+                                    ? Type.String
+                                    : Array.isArray(value)
+                                        ? Type.Array
+                                        : typeof value === 'object'
+                                            ? Type.Object
+                                            : Type.Function;
+    }
+    static isPrimitiveType(value) {
+        return value == null
+            || typeof value === 'boolean'
+            || value instanceof Date
+            || typeof value === 'number'
+            || typeof value === 'bigint'
+            || value instanceof ArrayBuffer
+            || typeof value === 'string';
+    }
+    static arrayType(itemTypes = []) {
+        return new Type([new ArrayAtom(itemTypes)]);
+    }
+    static objectType(propTypes = {}) {
+        return new Type([new ObjectAtom(propTypes)]);
+    }
+    static functionType(retType, argTypes = [], isVariadic = false) {
+        return new Type([Type._functionAtom(retType, argTypes, isVariadic)]);
+    }
+    static Unknown = new Type();
+    static Void = Type._primitiveType('void');
+    static Boolean = Type._primitiveType('boolean');
+    static OptionalBoolean = Type.union(Type.Void, Type.Boolean);
+    static Timestamp = Type._primitiveType('timestamp');
+    static OptionalTimestamp = Type.union(Type.Void, Type.Timestamp);
+    static Float = Type._primitiveType('float');
+    static OptionalFloat = Type.union(Type.Void, Type.Float);
+    static Integer = Type._primitiveType('integer');
+    static OptionalInteger = Type.union(Type.Void, Type.Integer);
+    static Buffer = Type._primitiveType('buffer');
+    static OptionalBuffer = Type.union(Type.Void, Type.Buffer);
+    static String = Type._primitiveType('string');
+    static OptionalString = Type.union(Type.Void, Type.String);
+    static Array = Type.arrayType();
+    static OptionalArray = Type.union(Type.Void, Type.Array);
+    static Object = Type.objectType();
+    static OptionalObject = Type.union(Type.Void, Type.Object);
+    static Function = Type.functionType();
+    static OptionalFunction = Type.union(Type.Void, Type.Function);
+    static Number = Type.union(Type.Float, Type.Integer);
+    static OptionalNumber = Type.union(Type.Void, Type.Float, Type.Integer);
+    static Enumerable = Type.union(Type.Buffer, Type.String, Type.Array);
+    static OptionalEnumerable = Type.union(Type.Void, Type.Buffer, Type.String, Type.Array);
+    static Iterable = Type.union(Type.Buffer, Type.String, Type.Array, Type.Object);
+    static OptionalIterable = Type.union(Type.Void, Type.Buffer, Type.String, Type.Array, Type.Object);
+    static _primitiveType(primitive) {
+        return new Type([new PrimitiveAtom(primitive)]);
+    }
+    static _functionAtom(retType, argTypes = [], isVariadic = false) {
+        let ix = 0;
+        while (ix < argTypes.length && !argTypes[ix].isOptional) {
+            ++ix;
+        }
+        const minArity = ix;
+        if (ix < argTypes.length) {
+            while (ix < argTypes.length && argTypes[ix].isOptional) {
+                ++ix;
+            }
+            if (ix < argTypes.length) {
+                throw new Error('a required parameter illegally follows an optional one');
+            }
+        }
+        return new FunctionAtom(retType, argTypes, minArity, isVariadic);
+    }
+}

package/dst/Value.d.ts

@@ -0,0 +1,3 @@
+export type Value = void | undefined | null | number | boolean | Date | bigint | ArrayBuffer | string | Value[] | {
+    [key: string]: Value;
+} | ((...args: any[]) => Value);

package/dst/Value.js

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

package/dst/Variable.d.ts

@@ -0,0 +1,13 @@
+import { Value } from './Value.js';
+import { Type } from './Type.js';
+export declare class Variable {
+    protected _type: Type;
+    protected _constant: boolean;
+    protected _value?: Value;
+    constructor(_type?: Type, _constant?: boolean);
+    get value(): Value | undefined;
+    set value(value: Value | undefined);
+    get type(): Type;
+    set type(type: Type);
+    get constant(): boolean;
+}

package/dst/Variable.js

@@ -0,0 +1,25 @@
+import { Type } from './Type.js';
+export class Variable {
+    _type;
+    _constant;
+    _value;
+    constructor(_type = Type.Unknown, _constant = false) {
+        this._type = _type;
+        this._constant = _constant;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get type() {
+        return this._type;
+    }
+    set type(type) {
+        this._type = type;
+    }
+    get constant() {
+        return this._constant;
+    }
+}

package/dst/atom/ArrayAtom.d.ts

@@ -0,0 +1,11 @@
+import { IType } from '../Type.js';
+export declare class ArrayAtom implements IType {
+    protected readonly _itemTypes: IType[];
+    constructor(_itemTypes?: IType[]);
+    get empty(): boolean;
+    subtypes(): IType[];
+    itemType(index: number): IType | undefined;
+    match(type: IType): boolean;
+    weight(): number;
+    toString(): string;
+}

package/dst/atom/ArrayAtom.js

@@ -0,0 +1,38 @@
+export class ArrayAtom {
+    _itemTypes;
+    constructor(_itemTypes = []) {
+        this._itemTypes = _itemTypes;
+    }
+    get empty() {
+        return this._itemTypes.length === 0;
+    }
+    subtypes() {
+        return this._itemTypes;
+    }
+    itemType(index) {
+        return this._itemTypes[index];
+    }
+    match(type) {
+        if (type instanceof ArrayAtom) {
+            if (this.empty || type.empty) {
+                return true;
+            }
+            if (this.subtypes().length !== type.subtypes().length) {
+                return false;
+            }
+            for (let i = 0; i < this._itemTypes.length; ++i) {
+                if (!this._itemTypes[i].match(type._itemTypes[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    weight() {
+        return 0x10000 + this.subtypes().reduce((acc, i) => acc + i.weight(), 0);
+    }
+    toString() {
+        return `[${this._itemTypes.join(',')}]`;
+    }
+}

package/dst/atom/FunctionAtom.d.ts

@@ -0,0 +1,17 @@
+import { IType } from '../Type.js';
+export declare class FunctionAtom implements IType {
+    protected readonly _retType?: IType | undefined;
+    protected readonly _argTypes: IType[];
+    protected readonly _minArity: number;
+    protected readonly _isVariadic: boolean;
+    constructor(_retType?: IType | undefined, _argTypes?: IType[], _minArity?: number, _isVariadic?: boolean);
+    get retType(): IType | undefined;
+    get minArity(): number;
+    get maxArity(): number;
+    get isVariadic(): boolean;
+    subtypes(): IType[];
+    argType(index: number): IType;
+    match(type: IType): boolean;
+    weight(): number;
+    toString(): string;
+}

package/dst/atom/FunctionAtom.js

@@ -0,0 +1,54 @@
+export class FunctionAtom {
+    _retType;
+    _argTypes;
+    _minArity;
+    _isVariadic;
+    constructor(_retType, _argTypes = [], _minArity = _argTypes.length, _isVariadic = false) {
+        this._retType = _retType;
+        this._argTypes = _argTypes;
+        this._minArity = _minArity;
+        this._isVariadic = _isVariadic;
+    }
+    get retType() {
+        return this._retType;
+    }
+    get minArity() {
+        return this._minArity;
+    }
+    get maxArity() {
+        return this._isVariadic ? Number.POSITIVE_INFINITY : this._argTypes.length;
+    }
+    get isVariadic() {
+        return this._isVariadic;
+    }
+    subtypes() {
+        return this._retType ? [this._retType, ...this._argTypes] : [];
+    }
+    argType(index) {
+        return this._argTypes[index] ?? this._argTypes[this._argTypes.length - 1];
+    }
+    match(type) {
+        if (type instanceof FunctionAtom) {
+            if (!this._retType || !type._retType) {
+                return true;
+            }
+            if (!this._retType.match(type._retType) || this.minArity > type.maxArity || this.maxArity < type.minArity) {
+                return false;
+            }
+            for (let i = 0, argc = Math.max(this.minArity, type.minArity); i < argc; ++i) {
+                if (!this.argType(i).match(type.argType(i))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    weight() {
+        return 0x1000000000000 + this.subtypes().reduce((acc, i) => acc + i.weight(), 0);
+    }
+    toString() {
+        const argTypes = this._argTypes.map((i) => i.toString()).join(',');
+        return this._retType ? `~${this._retType.toString()}(${argTypes}${this.isVariadic ? '...' : ''})` : '~()';
+    }
+}

package/dst/atom/ObjectAtom.d.ts

@@ -0,0 +1,11 @@
+import { IType } from '../Type.js';
+export declare class ObjectAtom implements IType {
+    protected readonly _propTypes: Record<string, IType>;
+    constructor(_propTypes?: Record<string, IType>);
+    get empty(): boolean;
+    subtypes(): IType[];
+    propType(property: string): IType;
+    match(type: IType): boolean;
+    weight(): number;
+    toString(): string;
+}

package/dst/atom/ObjectAtom.js

@@ -0,0 +1,44 @@
+export class ObjectAtom {
+    _propTypes;
+    constructor(_propTypes = {}) {
+        this._propTypes = _propTypes;
+    }
+    get empty() {
+        return Object.keys(this._propTypes).length === 0;
+    }
+    subtypes() {
+        return Object.values(this._propTypes);
+    }
+    propType(property) {
+        return this._propTypes[property];
+    }
+    match(type) {
+        if (type instanceof ObjectAtom) {
+            if (this.empty || type.empty) {
+                return true;
+            }
+            for (const prop in this._propTypes) {
+                if (!type.propType(prop)) {
+                    return false;
+                }
+                if (!this._propTypes[prop].match(type._propTypes[prop])) {
+                    return false;
+                }
+            }
+            for (const prop in type._propTypes) {
+                if (!this.propType(prop)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    weight() {
+        return 0x100000000 + this.subtypes().reduce((acc, i) => acc + i.weight(), 0);
+    }
+    toString() {
+        const entries = Object.entries(this._propTypes);
+        return entries.length ? `[${entries.map((i) => i[0] + ':' + i[1].toString()).join(',')}]` : '[:]';
+    }
+}

package/dst/atom/PrimitiveAtom.d.ts

@@ -0,0 +1,8 @@
+import { IType, Primitive } from '../Type.js';
+export declare class PrimitiveAtom implements IType {
+    protected readonly _primitive: Primitive;
+    constructor(_primitive?: Primitive);
+    match(type: IType): boolean;
+    weight(): number;
+    toString(): string;
+}

package/dst/atom/PrimitiveAtom.js

@@ -0,0 +1,26 @@
+export class PrimitiveAtom {
+    _primitive;
+    constructor(_primitive = 'void') {
+        this._primitive = _primitive;
+    }
+    match(type) {
+        if (type instanceof PrimitiveAtom) {
+            return type._primitive === this._primitive;
+        }
+        return false;
+    }
+    weight() {
+        switch (this._primitive) {
+            case 'void': return 0x0;
+            case 'boolean': return 0x2;
+            case 'timestamp': return 0x3;
+            case 'float': return 0x8;
+            case 'integer': return 0x10;
+            case 'buffer': return 0x20;
+            case 'string': return 0x30;
+        }
+    }
+    toString() {
+        return this._primitive;
+    }
+}