libmodulor 0.1.0 → 0.3.0

package/dist/esm/dt/base/TBase.js

@@ -0,0 +1,120 @@
+import { isBlank } from '../../utils/index.js';
+import { Validation } from '../Validation.js';
+export class TBase {
+    static DEFAULT_OPTIONS = {
+        shouldTranslateLabels: false,
+        strict: true,
+    };
+    defaultValue;
+    examples;
+    initialValue;
+    options;
+    optionsOpts;
+    raw;
+    semanticsMapping;
+    semanticsPredicate;
+    assign(raw) {
+        this.raw = raw;
+        return this;
+    }
+    autoCapitalizeBehavior() {
+        return undefined;
+    }
+    clear() {
+        this.raw = undefined;
+    }
+    example() {
+        throw new Error('An example must be defined');
+    }
+    fmt(ifNullOrUndefined = '-') {
+        const val = this.val();
+        if (val === undefined || val === null) {
+            return ifNullOrUndefined;
+        }
+        return `${val}`;
+    }
+    getDefaultValue() {
+        return this.defaultValue;
+    }
+    getExamples() {
+        return this.examples;
+    }
+    getInitialValue() {
+        return this.initialValue;
+    }
+    getOptions() {
+        return this.options;
+    }
+    getSemanticsMapping() {
+        return this.semanticsMapping;
+    }
+    getSemanticsPredicate() {
+        return this.semanticsPredicate;
+    }
+    hasOptions() {
+        return !isBlank(this.options);
+    }
+    hasStrictOptions() {
+        return this.optionsOpts?.strict ?? TBase.DEFAULT_OPTIONS.strict;
+    }
+    htmlInputType() {
+        return 'text';
+    }
+    isSensitive() {
+        return false;
+    }
+    rnInputMode() {
+        return 'text';
+    }
+    setDefaultValue(defaultValue) {
+        this.defaultValue = defaultValue;
+        return this;
+    }
+    setExamples(examples) {
+        this.examples = examples;
+        return this;
+    }
+    setInitialValue(initialValue) {
+        this.initialValue = initialValue;
+        return this;
+    }
+    restrictOptions(v) {
+        this.options = this.options?.filter((o) => v.includes(o.value));
+        return this;
+    }
+    setOptions(options, opts) {
+        this.options = options;
+        this.optionsOpts = opts;
+        if (this.options.length > 0 && this.options[0]) {
+            this.setExamples([this.options[0].value]);
+        }
+        return this;
+    }
+    setSemanticsMapping(semanticsMapping) {
+        this.semanticsMapping = semanticsMapping;
+        return this;
+    }
+    setSemanticsPredicate(semanticsPredicate) {
+        this.semanticsPredicate = semanticsPredicate;
+        return this;
+    }
+    shouldTranslateOptions() {
+        return (this.optionsOpts?.shouldTranslateLabels ??
+            TBase.DEFAULT_OPTIONS.shouldTranslateLabels);
+    }
+    val() {
+        return this.raw;
+    }
+    validate() {
+        const validation = new Validation();
+        if (this.options &&
+            this.hasStrictOptions() &&
+            !this.options.find((o) => o.value === this.raw)) {
+            validation.add({
+                constraint: 'oneOf',
+                expected: this.options.map((o) => o.value),
+            });
+        }
+        return validation;
+    }
+}

package/dist/esm/dt/base/TBoolean.d.ts

@@ -0,0 +1,10 @@
+import type { Validation } from '../Validation.js';
+import type { HTMLInputType } from '../targets/web.js';
+import { TBase, type TName } from './TBase.js';
+export declare class TBoolean extends TBase<boolean> {
+    tName(): TName;
+    assign(raw: unknown): this;
+    example(): boolean;
+    htmlInputType(): HTMLInputType;
+    validate(): Validation;
+}

package/dist/esm/dt/base/TBoolean.js

@@ -0,0 +1,38 @@
+import { TBase } from './TBase.js';
+export class TBoolean extends TBase {
+    tName() {
+        return 'Boolean';
+    }
+    assign(raw) {
+        if (typeof raw !== 'string') {
+            super.assign(raw);
+            return this;
+        }
+        if (raw === 'true') {
+            super.assign(true);
+            return this;
+        }
+        if (raw === 'false') {
+            super.assign(false);
+            return this;
+        }
+        super.assign(raw);
+        return this;
+    }
+    example() {
+        return true;
+    }
+    htmlInputType() {
+        return 'checkbox';
+    }
+    validate() {
+        const validation = super.validate();
+        if (typeof this.raw !== 'boolean') {
+            validation.add({
+                constraint: 'type',
+                expected: 'boolean',
+            });
+        }
+        return validation;
+    }
+}

package/dist/esm/dt/base/TInt.d.ts

@@ -0,0 +1,20 @@
+import type { Unit } from '../../utils/index.js';
+import type { Validation } from '../Validation.js';
+import type { RNInputMode } from '../targets/rn.js';
+import type { TName } from './TBase.js';
+import { TNumber, type TNumberConstraints } from './TNumber.js';
+export type Int = number;
+export type TIntConstraints = TNumberConstraints<Int>;
+export declare class TInt<T extends Int = Int> extends TNumber<T> {
+    static readonly DEFAULT_MAX: Int;
+    static readonly DEFAULT_MIN: Int;
+    constructor(constraints?: TIntConstraints, unit?: Unit, step?: T);
+    tName(): TName;
+    assign(raw: unknown): this;
+    example(): T;
+    getConstraints(): TIntConstraints | undefined;
+    max(): NonNullable<TIntConstraints['max']>;
+    min(): NonNullable<TIntConstraints['min']>;
+    rnInputMode(): RNInputMode;
+    validate(): Validation;
+}

package/dist/esm/dt/base/TInt.js

@@ -0,0 +1,53 @@
+import { TNumber } from './TNumber.js';
+export class TInt extends TNumber {
+    static DEFAULT_MAX = Number.MAX_SAFE_INTEGER;
+    static DEFAULT_MIN = Number.MIN_SAFE_INTEGER;
+    constructor(constraints, unit, step) {
+        super(constraints, undefined, unit, step);
+    }
+    tName() {
+        return 'Int';
+    }
+    assign(raw) {
+        if (typeof raw !== 'string') {
+            super.assign(raw);
+            return this;
+        }
+        const parsed = Number.parseInt(raw, 10);
+        if (Number.isNaN(parsed)) {
+            super.assign(raw);
+            return this;
+        }
+        if (parsed.toString() !== raw) {
+            super.assign(raw);
+            return this;
+        }
+        super.assign(parsed);
+        return this;
+    }
+    example() {
+        return 1;
+    }
+    getConstraints() {
+        return this.constraints;
+    }
+    max() {
+        return this.constraints?.max ?? TInt.DEFAULT_MAX;
+    }
+    min() {
+        return this.constraints?.min ?? TInt.DEFAULT_MIN;
+    }
+    rnInputMode() {
+        return 'numeric';
+    }
+    validate() {
+        const validation = super.validate();
+        if (typeof this.raw === 'number' && this.raw.toString().includes('.')) {
+            validation.add({
+                constraint: 'type',
+                expected: 'int',
+            });
+        }
+        return validation;
+    }
+}

package/dist/esm/dt/base/TNumber.d.ts

@@ -0,0 +1,31 @@
+import { type Unit } from '../../utils/index.js';
+import type { Validation } from '../Validation.js';
+import type { UIntQuantity } from '../final/TUIntQuantity.js';
+import type { RNInputMode } from '../targets/rn.js';
+import type { HTMLInputType } from '../targets/web.js';
+import { TBase, type TName } from './TBase.js';
+export interface TNumberConstraints<T extends number> {
+    max?: T;
+    min?: T;
+}
+export declare class TNumber<T extends number = number> extends TBase<T> {
+    protected constraints?: TNumberConstraints<number> | undefined;
+    protected decimalsCount?: UIntQuantity | undefined;
+    protected unit?: Unit | undefined;
+    protected step?: T | undefined;
+    static readonly DEFAULT_MAX: number;
+    static readonly DEFAULT_MIN: number;
+    constructor(constraints?: TNumberConstraints<number> | undefined, decimalsCount?: UIntQuantity | undefined, unit?: Unit | undefined, step?: T | undefined);
+    tName(): TName;
+    assign(raw: unknown): this;
+    example(): T;
+    fmt(ifNullOrUndefined?: string | undefined): string;
+    getConstraints(): TNumberConstraints<number> | undefined;
+    getDecimalsCount(): UIntQuantity | undefined;
+    getStep(): T | undefined;
+    htmlInputType(): HTMLInputType;
+    max(): NonNullable<TNumberConstraints<number>['max']>;
+    min(): NonNullable<TNumberConstraints<number>['min']>;
+    rnInputMode(): RNInputMode;
+    validate(): Validation;
+}

package/dist/esm/dt/base/TNumber.js

@@ -0,0 +1,83 @@
+import { fmtNumber } from '../../utils/index.js';
+import { TBase } from './TBase.js';
+export class TNumber extends TBase {
+    constraints;
+    decimalsCount;
+    unit;
+    step;
+    static DEFAULT_MAX = Number.MAX_VALUE;
+    static DEFAULT_MIN = -Number.MAX_VALUE;
+    constructor(constraints, decimalsCount, unit, step) {
+        super();
+        this.constraints = constraints;
+        this.decimalsCount = decimalsCount;
+        this.unit = unit;
+        this.step = step;
+    }
+    tName() {
+        return 'Number';
+    }
+    assign(raw) {
+        if (typeof raw !== 'string') {
+            super.assign(raw);
+            return this;
+        }
+        const parsed = Number.parseFloat(raw);
+        super.assign(parsed);
+        return this;
+    }
+    example() {
+        return 1.0;
+    }
+    fmt(ifNullOrUndefined) {
+        if (typeof this.raw !== 'number') {
+            return super.fmt(ifNullOrUndefined);
+        }
+        return fmtNumber(this.raw, this.unit, this.decimalsCount);
+    }
+    getConstraints() {
+        return this.constraints;
+    }
+    getDecimalsCount() {
+        return this.decimalsCount;
+    }
+    getStep() {
+        return this.step;
+    }
+    htmlInputType() {
+        return 'number';
+    }
+    max() {
+        return this.constraints?.max ?? TNumber.DEFAULT_MAX;
+    }
+    min() {
+        return this.constraints?.min ?? TNumber.DEFAULT_MIN;
+    }
+    rnInputMode() {
+        return 'decimal';
+    }
+    validate() {
+        const validation = super.validate();
+        if (typeof this.raw !== 'number' || Number.isNaN(this.raw)) {
+            validation.add({
+                constraint: 'type',
+                expected: 'number',
+            });
+        }
+        else {
+            if (this.raw < this.min()) {
+                validation.add({
+                    constraint: 'min',
+                    expected: this.min(),
+                });
+            }
+            if (this.raw > this.max()) {
+                validation.add({
+                    constraint: 'max',
+                    expected: this.max(),
+                });
+            }
+        }
+        return validation;
+    }
+}

package/dist/esm/dt/base/TObject.d.ts

@@ -0,0 +1,18 @@
+import type { Validation } from '../Validation.js';
+import { TBase, type TName } from './TBase.js';
+export declare enum TObjectShapeValidationStrategy {
+    NONE = "NONE",
+    SAME_AS_EXAMPLE = "SAME_AS_EXAMPLE"
+}
+export interface TObjectConstraints {
+    shapeValidationStrategy: TObjectShapeValidationStrategy;
+}
+export declare class TObject<T extends object> extends TBase<T> {
+    protected constraints: TObjectConstraints;
+    constructor(constraints?: TObjectConstraints);
+    tName(): TName;
+    example(): T;
+    fmt(ifNullOrUndefined?: string | undefined): string;
+    validate(): Validation;
+    private valueAndExampleHaveSameKeys;
+}

package/dist/esm/dt/base/TObject.js

@@ -0,0 +1,66 @@
+import { TBase } from './TBase.js';
+export var TObjectShapeValidationStrategy;
+(function (TObjectShapeValidationStrategy) {
+    TObjectShapeValidationStrategy["NONE"] = "NONE";
+    TObjectShapeValidationStrategy["SAME_AS_EXAMPLE"] = "SAME_AS_EXAMPLE";
+})(TObjectShapeValidationStrategy || (TObjectShapeValidationStrategy = {}));
+export class TObject extends TBase {
+    constraints;
+    constructor(constraints = {
+        shapeValidationStrategy: TObjectShapeValidationStrategy.SAME_AS_EXAMPLE,
+    }) {
+        super();
+        this.constraints = constraints;
+    }
+    tName() {
+        return 'Object';
+    }
+    example() {
+        return {};
+    }
+    fmt(ifNullOrUndefined) {
+        if (this.raw === null || typeof this.raw !== 'object') {
+            return super.fmt(ifNullOrUndefined);
+        }
+        return JSON.stringify(this.raw);
+    }
+    validate() {
+        const validation = super.validate();
+        if (this.raw === null || typeof this.raw !== 'object') {
+            validation.add({
+                constraint: 'type',
+                expected: 'object',
+            });
+        }
+        else {
+            const strategy = this.constraints?.shapeValidationStrategy;
+            switch (strategy) {
+                case TObjectShapeValidationStrategy.NONE:
+                    break;
+                case TObjectShapeValidationStrategy.SAME_AS_EXAMPLE: {
+                    const [isValid, expectedKeys] = this.valueAndExampleHaveSameKeys();
+                    if (!isValid) {
+                        validation.add({
+                            constraint: 'shape',
+                            expected: ['=~', expectedKeys],
+                        });
+                    }
+                    break;
+                }
+                default:
+                    ((_) => { })(strategy);
+            }
+        }
+        return validation;
+    }
+    valueAndExampleHaveSameKeys() {
+        const valueKeys = Object.keys(this.raw ?? {}).sort((a, b) => a.localeCompare(b));
+        const example = this.example();
+        const exampleKeys = Object.keys(example).sort((a, b) => a.localeCompare(b));
+        return [
+            valueKeys.length === exampleKeys.length &&
+                valueKeys.join('') === exampleKeys.join(''),
+            exampleKeys,
+        ];
+    }
+}

package/dist/esm/dt/base/TString.d.ts

@@ -0,0 +1,22 @@
+import type { Validation, ViolationFormat } from '../Validation.js';
+import { TBase, type TName } from './TBase.js';
+export interface TStringConstraints<VF extends ViolationFormat | (string & {}) = ViolationFormat> {
+    format?: {
+        f: VF;
+        regexp: RegExp;
+    } | undefined;
+    maxLength?: number;
+    minLength?: number;
+}
+export declare class TString<T extends string = string, VF extends ViolationFormat | (string & {}) = ViolationFormat> extends TBase<T> {
+    private constraints?;
+    static readonly DEFAULT_MAX_LENGTH = 999999;
+    static readonly DEFAULT_MIN_LENGTH = 0;
+    constructor(constraints?: TStringConstraints<VF> | undefined);
+    tName(): TName;
+    example(): T;
+    getConstraints(): TStringConstraints<VF> | undefined;
+    isPotentiallyLong(): boolean;
+    protected removeFormatConstraint(): void;
+    validate(): Validation;
+}

package/dist/esm/dt/base/TString.js

@@ -0,0 +1,62 @@
+import { TBase } from './TBase.js';
+export class TString extends TBase {
+    constraints;
+    static DEFAULT_MAX_LENGTH = 999_999;
+    static DEFAULT_MIN_LENGTH = 0;
+    constructor(constraints) {
+        super();
+        this.constraints = constraints;
+    }
+    tName() {
+        return 'String';
+    }
+    example() {
+        return 'Miami';
+    }
+    getConstraints() {
+        return this.constraints;
+    }
+    isPotentiallyLong() {
+        return false;
+    }
+    removeFormatConstraint() {
+        if (!this.constraints?.format) {
+            return;
+        }
+        this.constraints.format = undefined;
+    }
+    validate() {
+        const validation = super.validate();
+        if (typeof this.raw !== 'string') {
+            validation.add({
+                constraint: 'type',
+                expected: 'string',
+            });
+        }
+        else {
+            const length = this.raw.length;
+            const minLength = this.constraints?.minLength ?? TString.DEFAULT_MIN_LENGTH;
+            if (length < minLength) {
+                validation.add({
+                    constraint: 'minLength',
+                    expected: minLength,
+                });
+            }
+            const maxLength = this.constraints?.maxLength ?? TString.DEFAULT_MAX_LENGTH;
+            if (length > maxLength) {
+                validation.add({
+                    constraint: 'maxLength',
+                    expected: maxLength,
+                });
+            }
+            const format = this.constraints?.format;
+            if (format && !format.regexp.test(this.raw)) {
+                validation.add({
+                    constraint: 'format',
+                    expected: format.f,
+                });
+            }
+        }
+        return validation;
+    }
+}

package/dist/esm/dt/base/TUInt.d.ts

@@ -0,0 +1,12 @@
+import type { Unit } from '../../utils/index.js';
+import type { TName } from './TBase.js';
+import { TInt } from './TInt.js';
+import type { TNumberConstraints } from './TNumber.js';
+export type UInt = number;
+export type TUIntConstraints = TNumberConstraints<UInt>;
+export declare class TUInt<T extends UInt = UInt> extends TInt<T> {
+    constructor(constraints?: TUIntConstraints, unit?: Unit, step?: T);
+    tName(): TName;
+    example(): T;
+    min(): NonNullable<TUIntConstraints['min']>;
+}

package/dist/esm/dt/base/TUInt.js

@@ -0,0 +1,18 @@
+import { TInt } from './TInt.js';
+export class TUInt extends TInt {
+    constructor(constraints, unit, step) {
+        super(constraints, unit, step);
+        if (constraints?.min !== undefined && constraints.min < 0) {
+            throw new Error('The constraints of TUInt must be of type UInt. Got min < 0');
+        }
+    }
+    tName() {
+        return 'UInt';
+    }
+    example() {
+        return 1;
+    }
+    min() {
+        return this.constraints?.min ?? 0;
+    }
+}

package/dist/esm/dt/final/TAddress.d.ts

@@ -0,0 +1,7 @@
+import type { TName } from '../base/TBase.js';
+import { TString } from '../base/TString.js';
+export type Address = string;
+export declare class TAddress extends TString<Address> {
+    tName(): TName;
+    example(): Address;
+}

package/dist/esm/dt/final/TAddress.js

@@ -0,0 +1,9 @@
+import { TString } from '../base/TString.js';
+export class TAddress extends TString {
+    tName() {
+        return 'Address';
+    }
+    example() {
+        return '55 Rue du Faubourg Saint-Honoré, 75008 Paris';
+    }
+}

package/dist/esm/dt/final/TAmount.d.ts

@@ -0,0 +1,13 @@
+import type { TName } from '../base/TBase.js';
+import { TNumber, type TNumberConstraints } from '../base/TNumber.js';
+import type { CurrencyISO4217 } from './TCurrencyISO4217.js';
+import type { UIntQuantity } from './TUIntQuantity.js';
+export type Amount = number;
+export declare class TAmount extends TNumber {
+    protected currencyCode: CurrencyISO4217;
+    constructor(currencyCode: CurrencyISO4217, constraints?: TNumberConstraints<number>, decimalsCount?: UIntQuantity);
+    tName(): TName;
+    example(): Amount;
+    fmt(ifNullOrUndefined?: string | undefined): string;
+    getCurrencyCode(): CurrencyISO4217;
+}

package/dist/esm/dt/final/TAmount.js

@@ -0,0 +1,27 @@
+import { TNumber } from '../base/TNumber.js';
+export class TAmount extends TNumber {
+    currencyCode;
+    constructor(currencyCode, constraints, decimalsCount) {
+        super(constraints, decimalsCount);
+        this.currencyCode = currencyCode;
+    }
+    tName() {
+        return 'Amount';
+    }
+    example() {
+        return 999.99;
+    }
+    fmt(ifNullOrUndefined) {
+        if (typeof this.raw !== 'number') {
+            return super.fmt(ifNullOrUndefined);
+        }
+        return new Intl.NumberFormat(undefined, {
+            currency: this.currencyCode,
+            maximumFractionDigits: this.getDecimalsCount(),
+            style: 'currency',
+        }).format(this.raw);
+    }
+    getCurrencyCode() {
+        return this.currencyCode;
+    }
+}

package/dist/esm/dt/final/TApiKey.d.ts

@@ -0,0 +1,10 @@
+import type { TName } from '../base/TBase.js';
+import { TString } from '../base/TString.js';
+import type { HTMLInputType } from '../targets/web.js';
+export type ApiKey = string;
+export declare class TApiKey extends TString<ApiKey> {
+    tName(): TName;
+    example(): ApiKey;
+    htmlInputType(): HTMLInputType;
+    isSensitive(): boolean;
+}

package/dist/esm/dt/final/TApiKey.js

@@ -0,0 +1,15 @@
+import { TString } from '../base/TString.js';
+export class TApiKey extends TString {
+    tName() {
+        return 'ApiKey';
+    }
+    example() {
+        return 'pk_bxa2HCdsT7CKwVSdem8fjS8rW';
+    }
+    htmlInputType() {
+        return 'password';
+    }
+    isSensitive() {
+        return true;
+    }
+}

package/dist/esm/dt/final/TBarCode.d.ts

@@ -0,0 +1,7 @@
+import type { TName } from '../base/TBase.js';
+import { TString } from '../base/TString.js';
+export type BarCode = string;
+export declare class TBarCode extends TString<BarCode> {
+    tName(): TName;
+    example(): BarCode;
+}

package/dist/esm/dt/final/TBarCode.js

@@ -0,0 +1,9 @@
+import { TString } from '../base/TString.js';
+export class TBarCode extends TString {
+    tName() {
+        return 'BarCode';
+    }
+    example() {
+        return '3046920029759';
+    }
+}

package/dist/esm/dt/final/TCSS.d.ts

@@ -0,0 +1,8 @@
+import type { TName } from '../base/TBase.js';
+import { TString } from '../base/TString.js';
+export type CSS = string;
+export declare class TCSS extends TString<CSS> {
+    tName(): TName;
+    example(): CSS;
+    isPotentiallyLong(): boolean;
+}