@vorplex/core 0.0.4 → 0.0.9

package/dist/modules/state/adaptors/entity/entity-adaptor.util.js

@@ -0,0 +1,158 @@
+import { State } from '../../state.model';
+export class MapAdaptor {
+    constructor() { }
+    static delete(records, ...keys) {
+        records = { ...records };
+        for (const key of keys) {
+            delete records[key];
+        }
+        return records;
+    }
+    static set(records, items) {
+        records = { ...records };
+        for (const key in items) {
+            if (items[key] === undefined)
+                delete records[key];
+            else
+                records[key] = items[key];
+        }
+        return records;
+    }
+    static map(records, map) {
+        return MapAdaptor.fromArray(Object.values(records), map);
+    }
+    static fromArray(records, map) {
+        return records.reduce((records, record) => {
+            const [key, value] = map(record);
+            records[key] = value;
+            return records;
+        }, {});
+    }
+}
+export class EntityAdaptor {
+    key;
+    constructor(key) {
+        this.key = key;
+    }
+    static create(items, ...entities) {
+        items = { ...items };
+        for (const entity of entities) {
+            if (!items[entity.id]) {
+                items[entity.id] = entity;
+            }
+            else {
+                throw new Error(`Entity with ID ${entity.id} already exists.`);
+            }
+        }
+        return items;
+    }
+    create(...entities) {
+        return (state) => ({
+            [this.key]: EntityAdaptor.create(state[this.key], ...entities),
+        });
+    }
+    static updateAll(items, ...updates) {
+        items = { ...items };
+        for (const id in items) {
+            items[id] = State.update(items[id], ...updates);
+        }
+        return items;
+    }
+    updateAll(...updates) {
+        return (state) => ({
+            [this.key]: EntityAdaptor.updateAll(state[this.key], ...updates),
+        });
+    }
+    static updateById(items, id, ...updates) {
+        items = { ...items };
+        return EntityAdaptor.updateByIds(items, [id], ...updates);
+    }
+    updateById(id, ...updates) {
+        return (state) => ({
+            [this.key]: EntityAdaptor.updateById(state[this.key], id, ...updates),
+        });
+    }
+    static updateByIds(items, ids, ...updates) {
+        items = { ...items };
+        for (const id of ids) {
+            if (items[id]) {
+                items[id] = State.update(items[id], ...updates);
+            }
+            else {
+                throw new Error(`Entity with ID ${id} doesn't exist.`);
+            }
+        }
+        return items;
+    }
+    updateByIds(ids, ...updates) {
+        return (state) => ({
+            [this.key]: EntityAdaptor.updateByIds(state[this.key], ids, ...updates),
+        });
+    }
+    static updateWhere(items, predicate, ...updates) {
+        items = { ...items };
+        for (const item of Object.values(items).filter(predicate)) {
+            items[item.id] = State.update(item, ...updates);
+        }
+        return items;
+    }
+    updateWhere(predicate, ...updates) {
+        return (state) => ({
+            [this.key]: EntityAdaptor.updateWhere(state[this.key], predicate, ...updates),
+        });
+    }
+    static upsert(items, ...entities) {
+        items = { ...items };
+        for (const entity of entities) {
+            items[entity.id] = Object.assign({}, items[entity.id], entity);
+        }
+        return items;
+    }
+    static upsertBy(items, predicate, ...entities) {
+        items = { ...items };
+        for (const entity of entities) {
+            const existing = Object.values(items).find(existing => predicate(existing, entity));
+            items[existing?.id ?? entity.id] = Object.assign({}, existing, entity);
+        }
+        return items;
+    }
+    upsertBy(predicate, ...entities) {
+        return (state) => ({
+            [this.key]: EntityAdaptor.upsertBy(state[this.key], predicate, ...entities),
+        });
+    }
+    upsert(...entities) {
+        return (state) => ({
+            [this.key]: EntityAdaptor.upsert(state[this.key], ...entities),
+        });
+    }
+    static delete(items, ...ids) {
+        items = { ...items };
+        for (const id of ids) {
+            delete items[id];
+        }
+        return items;
+    }
+    delete(...ids) {
+        return (state) => ({
+            [this.key]: EntityAdaptor.delete(state[this.key], ...ids),
+        });
+    }
+    static deleteWhere(items, predicate) {
+        items = { ...items };
+        for (const item of Object.values(items)) {
+            if (predicate(item)) {
+                delete items[item.id];
+            }
+        }
+        return items;
+    }
+    deleteWhere(predicate) {
+        return (state) => ({
+            [this.key]: EntityAdaptor.deleteWhere(state[this.key], predicate),
+        });
+    }
+    static fromArray(entities) {
+        return entities.reduce((map, entity) => ({ ...map, [entity.id]: entity }), {});
+    }
+}

package/dist/modules/state/adaptors/entity/entity-map.type.d.ts

@@ -0,0 +1,4 @@
+import type { IEntity } from './entity.interface';
+export type EntityMap<T extends IEntity> = {
+    [id: string]: T;
+};

package/dist/modules/state/adaptors/entity/entity.interface.d.ts

@@ -0,0 +1,3 @@
+export interface IEntity {
+    readonly id: string;
+}

package/dist/modules/state/state.model.d.ts

@@ -0,0 +1,46 @@
+import type { Constructor } from '../reflection/types/constructor.type';
+import { Subscribable } from '../subscribable/subscribable.model';
+import type { Subscription } from '../subscribable/subscription.interface';
+import { ArrayAdaptor } from './adaptors/array/array-adaptor.util';
+import { EntityAdaptor } from './adaptors/entity/entity-adaptor.util';
+import type { EntityMap } from './adaptors/entity/entity-map.type';
+import type { IEntity } from './adaptors/entity/entity.interface';
+import type { Update } from './update.type';
+export interface StateChange<T> {
+    previousValue: T;
+    value: T;
+}
+export type StateEffect<T> = (value: T) => T;
+export declare class State<T = any, TReducer extends Constructor = Constructor> extends Subscribable<StateChange<T>> {
+    private reducer?;
+    private _value;
+    get value(): T;
+    constructor(state?: T, reducer?: TReducer);
+    static combineLatest<T extends any[]>(states: {
+        [K in keyof T]: State<T[K]>;
+    }, callback: (values: T) => void): Subscription;
+    reduce(update: (reducer: {
+        update: {
+            <V>(path: (state: T) => V, update: (value: V) => Partial<V>): Update<T>;
+            <V>(path: (state: T) => V, value: Partial<V>): Update<T>;
+        };
+    } & {
+        [K in keyof T]: T[K] extends EntityMap<IEntity> ? {
+            entity: EntityAdaptor<T, T[K] extends EntityMap<infer U> ? U : never, K & any>;
+        } & (K extends keyof InstanceType<TReducer> ? InstanceType<TReducer>[K & keyof InstanceType<TReducer>] : {}) : T[K] extends any[] ? {
+            array: ArrayAdaptor<T, T[K] extends (infer U)[] ? U : never, K & any>;
+        } & (K extends keyof InstanceType<TReducer> ? InstanceType<TReducer>[K & keyof InstanceType<TReducer>] : {}) : {
+            value: {
+                set: (value: T[K]) => Update<T> & (K extends keyof InstanceType<TReducer> ? InstanceType<TReducer>[K & keyof InstanceType<TReducer>] : {});
+            } & (K extends keyof InstanceType<TReducer> ? InstanceType<TReducer>[K & keyof InstanceType<TReducer>] : {});
+        };
+    }) => Update<T>[]): void;
+    subscribe(emit: (event: StateChange<T>, subscription: Subscription) => void): Subscription;
+    static update<TState>(state: TState, ...updates: Update<TState>[]): TState;
+    update(...updates: Update<T>[]): void;
+    set(value: T): void;
+    asReadOnly(): Subscribable<StateChange<T>> & {
+        readonly value: T;
+    };
+    sync(config: State<T>): Subscription;
+}

package/dist/modules/state/state.model.js

@@ -0,0 +1,129 @@
+import { $Reflection } from '../reflection/utils/reflection.util';
+import { Subscribable } from '../subscribable/subscribable.model';
+import { $Value } from '../value/value.util';
+import { ArrayAdaptor } from './adaptors/array/array-adaptor.util';
+import { EntityAdaptor } from './adaptors/entity/entity-adaptor.util';
+export class State extends Subscribable {
+    reducer;
+    _value;
+    get value() {
+        return this._value;
+    }
+    constructor(state, reducer) {
+        super();
+        this.reducer = reducer;
+        this._value = state;
+    }
+    static combineLatest(states, callback) {
+        const empty = Symbol();
+        const values = new State(states.map(() => empty));
+        const subscriptions = [
+            values.subscribe((values) => {
+                if (values.value.every((i) => i !== empty)) {
+                    callback(values.value);
+                }
+            }),
+        ];
+        for (const [index, state] of states.entries()) {
+            const subscription = state.subscribe((state) => {
+                values.update((values) => {
+                    values[index] = state.value;
+                    return values;
+                });
+            });
+            subscriptions.push(subscription);
+        }
+        return {
+            unsubscribe: () => {
+                for (const subscription of subscriptions) {
+                    subscription.unsubscribe();
+                }
+            },
+        };
+    }
+    reduce(update) {
+        const reducer = new Proxy({
+            update: (path, update) => {
+                return (state) => $Value.update(state, path, update);
+            },
+        }, {
+            get: (target, property) => {
+                if (property === 'update')
+                    return target.update;
+                const reducer = {
+                    entity: new EntityAdaptor(property),
+                    array: new ArrayAdaptor(property),
+                    value: {
+                        set: (value) => ({
+                            [property]: value,
+                        }),
+                    },
+                };
+                Object.assign(reducer, (this.reducer && new this.reducer()[property]) || {});
+                return reducer;
+            },
+        });
+        this.update(...update(reducer));
+    }
+    subscribe(emit) {
+        const subscription = super.subscribe(emit);
+        const event = {
+            previousValue: this.value,
+            value: this.value,
+        };
+        emit(event, subscription);
+        return subscription;
+    }
+    static update(state, ...updates) {
+        for (const update of updates) {
+            if ($Reflection.isFunction(update)) {
+                state = State.update(state, update(state));
+            }
+            else if ($Reflection.isObject(update)) {
+                const prototype = Object.getPrototypeOf(state ?? update);
+                state = Object.assign({}, state, update);
+                Object.setPrototypeOf(state, prototype);
+            }
+            else {
+                state = update;
+            }
+        }
+        return state;
+    }
+    update(...updates) {
+        this.set(State.update(this.value, ...updates));
+    }
+    set(value) {
+        const previousValue = this.value;
+        this._value = value;
+        this.emit({
+            previousValue,
+            value: this.value
+        });
+    }
+    asReadOnly() {
+        return this;
+    }
+    sync(config) {
+        let localValue;
+        let refValue;
+        const targetSubscription = config.subscribe(state => {
+            if (state.value !== localValue) {
+                refValue = state.value;
+                this.set(state.value);
+            }
+        });
+        const localSubscription = this.subscribe(state => {
+            if (state.value !== refValue) {
+                localValue = state.value;
+                config.set(state.value);
+            }
+        });
+        return {
+            unsubscribe: () => {
+                targetSubscription.unsubscribe();
+                localSubscription.unsubscribe();
+            }
+        };
+    }
+}

package/dist/modules/state/update.type.d.ts

@@ -0,0 +1,2 @@
+export type UpdateFunc<T> = (state: T) => Partial<T>;
+export type Update<T> = Partial<T> | UpdateFunc<T>;

package/dist/modules/string/string.util.d.ts

@@ -0,0 +1,11 @@
+export declare class $String {
+    static indent(string: string, spaces: number): string;
+    static toAlphanumeric(string: string, specialCharacterReplacement?: string): string;
+    static indexesOf(string: string, pattern: string): number[];
+    static upperCaseFirst(string: string): string;
+    static getWords(string: string): string[];
+    static camelCase(string: string): string;
+    static kebabCase(string: string): string;
+    static isNullOrEmpty(value: string): boolean;
+    static sanitizeForRegex(string: string): string;
+}

package/dist/modules/string/string.util.js

@@ -0,0 +1,42 @@
+export class $String {
+    static indent(string, spaces) {
+        return string?.replace(/^/gm, ' '.repeat(spaces));
+    }
+    static toAlphanumeric(string, specialCharacterReplacement) {
+        return string.replace(/[^a-zA-Z0-9]/g, specialCharacterReplacement ?? '');
+    }
+    static indexesOf(string, pattern) {
+        const indexes = [];
+        let index = string.indexOf(pattern);
+        while (index > -1) {
+            indexes.push(index);
+            index = string.indexOf(pattern, index + 1);
+        }
+        return indexes;
+    }
+    static upperCaseFirst(string) {
+        return string.slice(0, 1).toUpperCase() + string.slice(1);
+    }
+    static getWords(string) {
+        const regex = new RegExp(['[A-Z][a-z]+', '[A-Z]+(?=[A-Z][a-z])', '[A-Z]+', '[a-z]+', '[0-9]+'].join('|'), 'g');
+        return string.match(regex) ?? [];
+    }
+    static camelCase(string) {
+        return $String
+            .getWords(string)
+            .map((word, index) => (index === 0 ? word.toLowerCase() : $String.upperCaseFirst(word.toLowerCase())))
+            .join('');
+    }
+    static kebabCase(string) {
+        return $String
+            .getWords(string)
+            .map((word) => word.toLowerCase())
+            .join('-');
+    }
+    static isNullOrEmpty(value) {
+        return value == null || value === '';
+    }
+    static sanitizeForRegex(string) {
+        return string.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+    }
+}

package/dist/modules/subscribable/subscribable.model.d.ts

@@ -0,0 +1,10 @@
+import type { Subscription } from './subscription.interface';
+export declare class Subscribable<T> {
+    private listeners;
+    protected emit(event: T): void;
+    until(predicate: (value: T) => boolean): Promise<T>;
+    subscribe(emit: (event: T, subscription: Subscription) => void): Subscription;
+}
+export declare class Emitter<T> extends Subscribable<T> {
+    emit(event: T): void;
+}

package/dist/modules/subscribable/subscribable.model.js

@@ -0,0 +1,34 @@
+import { $Array } from '../array/array.util';
+export class Subscribable {
+    listeners = [];
+    emit(event) {
+        for (const listener of this.listeners) {
+            listener(event);
+        }
+    }
+    until(predicate) {
+        return new Promise((resolve) => {
+            this.subscribe((event, subscription) => {
+                if (predicate(event)) {
+                    subscription.unsubscribe();
+                    resolve(event);
+                }
+            });
+        });
+    }
+    subscribe(emit) {
+        const listener = event => emit(event, subscription);
+        const subscription = {
+            unsubscribe: () => {
+                this.listeners = $Array.remove(this.listeners, listener);
+            }
+        };
+        this.listeners.push(listener);
+        return subscription;
+    }
+}
+export class Emitter extends Subscribable {
+    emit(event) {
+        super.emit(event);
+    }
+}

package/dist/modules/subscribable/subscription.interface.d.ts

@@ -0,0 +1,3 @@
+export interface Subscription {
+    unsubscribe(): void;
+}

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

@@ -0,0 +1,8 @@
+import type { TsonSchema } from './schema';
+export declare class TsonError extends Error {
+    message: string;
+    value: any;
+    schema: TsonSchema;
+    path: string;
+    constructor(message: string, value: any, schema: TsonSchema, path?: string);
+}

package/dist/modules/tson/error.js

@@ -0,0 +1,13 @@
+export class TsonError extends Error {
+    message;
+    value;
+    schema;
+    path;
+    constructor(message, value, schema, path = '') {
+        super(message);
+        this.message = message;
+        this.value = value;
+        this.schema = schema;
+        this.path = path;
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { TsonAny, TsonAnyDefinition } from './schemas/any';
+import type { TsonArray, TsonArrayDefinition } from './schemas/array';
+import type { TsonBoolean, TsonBooleanDefinition } from './schemas/boolean';
+import type { TsonEnum, TsonEnumDefinition } from './schemas/enum';
+import type { TsonNumber, TsonNumberDefinition } from './schemas/number';
+import type { TsonObject, TsonObjectDefinition } from './schemas/object';
+import type { TsonString, TsonStringDefinition } from './schemas/string';
+import type { TsonUnion, TsonUnionDefinition } from './schemas/union';
+export type TsonDefinition = TsonEnumDefinition | TsonAnyDefinition | TsonArrayDefinition | TsonBooleanDefinition | TsonAnyDefinition | TsonNumberDefinition | TsonObjectDefinition | TsonStringDefinition | TsonUnionDefinition;
+export type TsonSchema = TsonString | TsonNumber | TsonBoolean | TsonArray | TsonEnum | TsonObject | TsonAny | TsonUnion;

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

@@ -0,0 +1,14 @@
+import type { TsonDefinition } from '../schema';
+import { type TsonDefinitionBase, TsonSchemaBase } from './schema-base';
+export interface TsonAnyDefinition extends TsonDefinitionBase {
+    type: 'any';
+    default?: any;
+}
+export declare class TsonAny extends TsonSchemaBase<any> {
+    definition: TsonAnyDefinition;
+    constructor(definition?: TsonAnyDefinition);
+    default(value: any): TsonAny;
+    getDefault(): any;
+    accepts(definition: TsonDefinition | null | undefined): boolean;
+    parse(value: any): any;
+}

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

@@ -0,0 +1,27 @@
+import { TsonSchemaBase } from './schema-base';
+export class TsonAny extends TsonSchemaBase {
+    definition;
+    constructor(definition = {
+        type: 'any',
+    }) {
+        super();
+        this.definition = definition;
+    }
+    default(value) {
+        return new TsonAny({
+            ...this.definition,
+            default: value,
+        });
+    }
+    getDefault() {
+        return this.definition.default ?? undefined;
+    }
+    accepts(definition) {
+        return true;
+    }
+    parse(value) {
+        if (this.parseDefault(value))
+            return this.definition.default;
+        return value;
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { TsonDefinition } from '../schema';
+import type { TsonType } from '../type';
+import { type TsonDefinitionBase, TsonSchemaBase } from './schema-base';
+export interface TsonArrayDefinition<T = any> extends TsonDefinitionBase {
+    readonly type: 'array';
+    min?: number;
+    max?: number;
+    default?: T[];
+    itemDefinition?: TsonDefinition;
+}
+export declare class TsonArray<T extends TsonDefinition = any> extends TsonSchemaBase<TsonType<T>[]> {
+    definition: TsonArrayDefinition<TsonType<T>>;
+    constructor(definition?: TsonArrayDefinition<TsonType<T>>);
+    default(value: any): TsonArray<T>;
+    minLength(length: number): TsonArray<T>;
+    maxLength(length: number): TsonArray<T>;
+    item(schema: TsonDefinition): TsonArray<T>;
+    getDefault(): TsonType<T>[];
+    accepts(definition: TsonDefinition | null | undefined): boolean;
+    parse(value: any): TsonType<T>[];
+}

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

@@ -0,0 +1,80 @@
+import { TsonError } from '../error';
+import { $Tson } from '../tson';
+import { TsonSchemaBase } from './schema-base';
+export class TsonArray extends TsonSchemaBase {
+    definition;
+    constructor(definition = {
+        type: 'array',
+    }) {
+        super();
+        this.definition = definition;
+    }
+    default(value) {
+        return new TsonArray({
+            ...this.definition,
+            default: value,
+        });
+    }
+    minLength(length) {
+        return new TsonArray({
+            ...this.definition,
+            min: length,
+        });
+    }
+    maxLength(length) {
+        return new TsonArray({
+            ...this.definition,
+            max: length,
+        });
+    }
+    item(schema) {
+        return new TsonArray({
+            ...this.definition,
+            itemDefinition: schema,
+        });
+    }
+    getDefault() {
+        return (this.definition.default ?? this.definition.itemDefinition) ? [$Tson.parse(this.definition.itemDefinition).getDefault()] : [];
+    }
+    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 !== 'array')
+            return false;
+        if (this.definition.max != null && this.definition.max < definition.max)
+            return false;
+        if (this.definition.min != null && this.definition.min < definition.min)
+            return false;
+        if (this.definition.itemDefinition != null && !$Tson.parse(this.definition.itemDefinition).accepts(definition.itemDefinition))
+            return false;
+        return true;
+    }
+    parse(value) {
+        if (this.parseDefault(value))
+            return this.definition.default;
+        if (value != null && !Array.isArray(value))
+            throw new TsonError('Array expected', value, this);
+        const array = value;
+        if (this.definition.min != null && array.length < this.definition.min)
+            throw new TsonError(`Array min length of ${this.definition.min} expected`, value, this);
+        if (this.definition.max != null && array.length > this.definition.max)
+            throw new TsonError(`Array max length of ${this.definition.max} expected`, value, this);
+        if (this.definition.itemDefinition) {
+            for (const [index, item] of array.entries()) {
+                try {
+                    array[index] = $Tson.parse(this.definition.itemDefinition).parse(item);
+                }
+                catch (error) {
+                    if (!(error instanceof TsonError))
+                        throw error;
+                    throw new TsonError(`Invalid item in array. ${error.message}`, item, this, `[${index}]${error.path}`);
+                }
+            }
+        }
+        return value;
+    }
+}

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

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