smoothly 1.2.1-alpha.23 → 1.2.1-alpha.25

package/dist/cjs/{Scrollable-a60d6091.js → Scrollable-20426515.js}

@@ -1,395 +1,47 @@
 'use strict';
 
-class Type {
-    get name() {
-        return typeof this._name == "function" ? this._name() : this._name;
-    }
-    get condition() {
-        return typeof this._condition == "function" ? this._condition() : this._condition;
-    }
-    optional() {
-        return new IslyOptional(this);
-    }
-    readonly() {
-        return new IslyReadonly(this);
-    }
-    array(...options) {
-        return array(this, ...options);
-    }
-    constructor(_name, _condition) {
-        this._name = _name;
-        this._condition = _condition;
-        /**
-         * Return a flaw object, describing the flaws of the value compared to expected type.
-         *
-         * If it is a correct value, according to the type, it returns a Flaw with the message `{message:"This type is correct.", isFlaw: false, ... }`
-         *
-         * Implemented as a closure.
-         */
-        this.flaw = (value) => {
-            return this.is(value)
-                ? {
-                    type: this.name,
-                    ...(this.condition ? { condition: this.condition } : undefined),
-                    isFlaw: false,
-                    message: "This type is correct.",
-                }
-                : {
-                    ...(this.condition ? { condition: this.condition } : undefined),
-                    ...this.createFlaw(value),
-                    type: this.name,
-                };
-        };
-    }
-    /**
-     * Return the value if the value is valid for the type, otherwise undefined.
-     * For objects, unknown properties are filtered.
-     *
-     * Eg: isly.number().value(NaN) returns undefined
-     */
-    get(value) {
-        return this.is(value) ? this.getValue(value) : undefined;
-    }
-    getValue(value) {
-        return value;
-    }
-    /**
-     * Override this to create custom Flaws.
-     * Not necessary for simple types.
-     */
-    createFlaw(value) {
-        return {};
-    }
-    /**
-     * Used by types that use a backend type.
-     */
-    createFlawFromType(backend, value) {
-        return "createFlaw" in backend && typeof backend.createFlaw == "function"
-            ? backend.createFlaw(value)
-            : backend.flaw(value);
-    }
-}
-class IslyOptional extends Type {
-    constructor(backend) {
-        super(() => backend.name + " | undefined", backend.condition);
-        this.backend = backend;
-        this.class = "optional";
-        this.is = (value) => value == undefined || this.backend.is(value);
-    }
-    createFlaw(value) {
-        return this.createFlawFromType(this.backend, value);
-    }
-}
-class IslyReadonly extends Type {
-    constructor(backend) {
-        super(() => `Readonly<${backend.name}>`, backend.condition);
-        this.backend = backend;
-        this.class = "readonly";
-        this.is = (value) => value == undefined || this.backend.is(value);
-    }
-    createFlaw(value) {
-        return this.createFlawFromType(this.backend, value);
-    }
-}
-function array(itemType, ...options) {
-    return new IslyArray(itemType, options);
-}
-const criteriaFunctions$1 = {
-    length: {
-        is: (value, optionValue) => value.length == optionValue,
-        condition: optionValue => `length == ${optionValue}`,
-    },
-    minLength: {
-        is: (value, optionValue) => value.length >= optionValue,
-        condition: optionValue => `minLength == ${optionValue}`,
-    },
-    maxLength: {
-        is: (value, optionValue) => value.length <= optionValue,
-        condition: optionValue => `maxLength == ${optionValue}`,
-    },
-};
-class IslyArray extends Type {
-    constructor(itemType, options) {
-        super(() => this.baseName() + "[]", options.length > 0 ? options.map(c => criteriaFunctions$1[c.criteria].condition(c.value)).join(" & ") : undefined);
-        this.itemType = itemType;
-        this.options = options;
-        this.class = "array";
-        this.is = (value) => globalThis.Array.isArray(value) &&
-            this.options.every(option => criteriaFunctions$1[option.criteria].is(value, option.value)) &&
-            value.every(item => this.itemType.is(item));
-    }
-    baseName() {
-        return this.itemType.name.includes(" ") ? `(${this.itemType.name})` : this.itemType.name;
-    }
-    itemName(index) {
-        return `${this.baseName()}[${index}]`;
-    }
-    createFlaw(value) {
-        const flaws = (globalThis.Array.isArray(value) &&
-            value.flatMap((item, index) => {
-                const subFlaw = this.itemType.flaw(item);
-                return subFlaw.isFlaw ?? true ? [{ ...subFlaw, type: this.itemName(index) }] : [];
-            })) ||
-            [];
-        return {
-            ...(flaws.length > 0 ? { flaws } : undefined),
-        };
-    }
-    getValue(value) {
-        return value.map(item => this.itemType.get(item));
-    }
-}
-
-function boolean(booleanValue) {
-    return new IslyBoolean(booleanValue);
-}
-class IslyBoolean extends Type {
-    constructor(booleanValue) {
-        super(booleanValue == undefined ? "boolean" : booleanValue ? "true" : "false");
-        this.booleanValue = booleanValue;
-        this.class = "boolean";
-        this.is = (value) => typeof value == "boolean" && (this.booleanValue == undefined || value == this.booleanValue);
-    }
-}
-
-/**
- * Late evaluation of a type
- * Can be used for for recursive types.
- *
- * @param factory
- * @param name Provide a name, to avoid infinite loop if the type i recursive
- * @returns
- */
-function lazy(factory, name) {
-    return new IslyLazy(factory, name);
-}
-class IslyLazy extends Type {
-    constructor(factory, name) {
-        super(name ?? (() => (this.backend ??= factory()).name), () => (this.backend ??= factory()).condition);
-        this.factory = factory;
-        this.class = "lazy";
-        this.is = (value) => (this.backend ??= this.factory()).is(value);
-    }
-    createFlaw(value) {
-        return this.createFlawFromType((this.backend ??= this.factory()), value);
-    }
-    getBackend() {
-        return this.backend;
-    }
-    get(value) {
-        return this.backend.get(value);
-    }
-}
-
-function object(properties, name) {
-    return new IslyObject(properties ?? {}, name);
-}
-class IslyObject extends Type {
-    constructor(properties, name, baseType) {
-        super(() => name ??
-            (this.baseType ? `${this.baseType.name} & ` : "") +
-                `{${globalThis.Object.entries(this.properties)
-                    .map(([property, type]) => `${property}: ${type.name}`)
-                    .join(", ")}}`);
-        this.properties = properties;
-        this.baseType = baseType;
-        this.class = "object";
-        this.is = (value) => !!(value &&
-            (this.baseType == undefined || this.baseType.is(value)) &&
-            typeof value == "object" &&
-            !globalThis.Array.isArray(value) &&
-            globalThis.Object.entries(this.properties).every(([property, type]) => type.is(value[property])));
-    }
-    extend(properties, name) {
-        return new IslyObject(properties, name, this);
-    }
-    omit(omits, name) {
-        return new IslyObject(globalThis.Object.fromEntries(globalThis.Object.entries(this.properties).filter(([key]) => !omits.includes(key))), name ?? `Omit<${this.name}, ${omits.map(key => `"${String(key)}"`).join(" | ")}>`, this.baseType?.omit(omits));
-    }
-    pick(picks, name) {
-        return new IslyObject(globalThis.Object.fromEntries(globalThis.Object.entries(this.properties).filter(([key]) => picks.includes(key))), name ?? `Pick<${this.name}, ${picks.map(key => `"${String(key)}"`).join(" | ")}>`, this.baseType?.pick(picks));
-    }
-    createFlaw(value) {
-        return {
-            flaws: [
-                this.baseType ? this.baseType.flaw(value)?.flaws ?? [] : [],
-                globalThis.Object.entries(this.properties)
-                    .map(([property, type]) => [property, type.flaw(value?.[property])])
-                    .map(([property, flaw]) => (flaw?.isFlaw ?? true) && { property, ...flaw })
-                    .filter(flaw => flaw),
-            ]
-                .flat()
-                .filter(flaw => flaw?.isFlaw ?? true),
-        };
-    }
-    /**
-     * get-function on a object returns a object with only specified properties
-     */
-    getValue(value) {
-        const result = this.baseType ? this.baseType.getValue(value) : {};
-        if (result)
-            for (const [key, type] of globalThis.Object.entries(this.properties))
-                if (key in value)
-                    result[key] = type.get(value[key]);
-        return result;
-    }
-    getProperties() {
-        return { ...this.baseType?.getProperties(), ...this.properties };
-    }
-}
-
-function string(condition) {
-    return new IslyString(condition);
-}
-class IslyString extends Type {
-    constructor(stringCondition) {
-        super(typeof stringCondition == "string" ? `"${stringCondition}"` : "string", () => {
-            const conditionObject = this.getConditionObject();
-            return conditionObject instanceof RegExp
-                ? `/${conditionObject.source}/${conditionObject.flags}`
-                : globalThis.Object.keys(conditionObject)
-                    .map(key => `"${key}"`)
-                    .join(" | ");
-        });
-        this.stringCondition = stringCondition;
-        this.class = "string";
-        this.is = (value) => {
-            const conditionObject = this.getConditionObject();
-            return (typeof value == "string" &&
-                (conditionObject instanceof RegExp
-                    ? conditionObject.test(value)
-                    : typeof conditionObject == "object"
-                        ? value in conditionObject //TODO, avoid "hasOwnProperty toString etc."
-                        : conditionObject));
-        };
-    }
-    getConditionObject() {
-        return (this.conditionObject ??= Array.isArray(this.stringCondition)
-            ? this.stringCondition.reduce((result, current) => {
-                result[current] = true;
-                return result;
-            }, globalThis.Object.create(null))
-            : typeof this.stringCondition == "string"
-                ? { [this.stringCondition]: true }
-                : typeof this.stringCondition == "object" // Record or RegExp!
-                    ? this.stringCondition
-                    : true);
-    }
-}
-
-var Flaw;
-(function (Flaw) {
-    Flaw.type = object({
-        message: string().optional(),
-        isFlaw: boolean().optional(),
-        property: string().optional(),
-        type: string(),
-        flaws: array(lazy(() => Flaw.type)).optional(),
-        condition: string().optional(),
-    }, "Flaw");
-    Flaw.is = Flaw.type.is;
-    Flaw.flaw = Flaw.type.flaw;
-})(Flaw || (Flaw = {}));
+const TimeZone = require('./TimeZone-c7477083.js');
 
 function fromIs(name, is) {
     return new IslyFromIs(name, is);
 }
-class IslyFromIs extends Type {
+class IslyFromIs extends TimeZone.Type {
+    isFunction;
+    class = "fromIs";
     constructor(name, isFunction) {
         super(name);
         this.isFunction = isFunction;
-        this.class = "fromIs";
-        this.is = (value) => this.isFunction(value);
     }
+    is = (value) => this.isFunction(value);
 }
 
-// eslint-disable-next-line @typescript-eslint/ban-types
 function islyFunction() {
     return new IslyFunction();
 }
-// eslint-disable-next-line @typescript-eslint/ban-types
-class IslyFunction extends Type {
+class IslyFunction extends TimeZone.Type {
+    class = "function";
     constructor() {
         super("function");
-        this.class = "function";
-        this.is = (value) => !!(value && typeof value == "function");
-    }
-}
-
-const criteriaFunctions = {
-    positive: {
-        is: (value) => value > 0,
-        condition: "> 0",
-    },
-    negative: {
-        is: (value) => value < 0,
-        condition: "< 0",
-    },
-    integer: {
-        is: (value) => Number.isInteger(value),
-        condition: "Number.isInteger",
-    },
-};
-/**
- * NaN, Infinite and -Infinite is not considered to be numbers by this type,
- * since that it is hardly ever desirable when validating input data.
- *
- * @param criteria
- * @returns
- */
-function number(criteria) {
-    const [isFunction, condition] = criteria == undefined ? [undefined, undefined] : fromCriteria(criteria);
-    return new IslyNumber(isFunction, condition);
-}
-function fromCriteria(criteria) {
-    return /* Eg: criteria == 42 */ typeof criteria == "number"
-        ? [value => value == criteria, " == " + criteria.toString()]
-        : // Eg: criteria == [0,1,2]
-            ((c) => Array.isArray(c) && c.every(c => typeof c == "number"))(criteria)
-                ? [value => criteria.map(fromCriteria).some(c => c[0](value)), criteria.join(" | ")]
-                : // Eg: criteria ==  ["positive", "negative"]
-                    ((c) => Array.isArray(c) && c.every(c => typeof c == "string" && c in criteriaFunctions))(criteria)
-                        ? [
-                            value => criteria.map(fromCriteria).every(c => c[0](value)),
-                            criteria
-                                .map(fromCriteria)
-                                .map(c => c[1])
-                                .join(" & "),
-                        ]
-                        : // Eg: criteria == () => true
-                            typeof criteria === "function"
-                                ? [criteria, "custom"]
-                                : // Eg: criteria == "positive"
-                                    criteria in criteriaFunctions
-                                        ? [criteriaFunctions[criteria].is, criteriaFunctions[criteria].condition]
-                                        : // Eg: criteria is unknown
-                                            [() => false, "Unknown criteria"];
-}
-class IslyNumber extends Type {
-    constructor(isFunction, condition) {
-        super("number", condition);
-        this.isFunction = isFunction;
-        this.class = "number";
-        this.is = (value) => typeof value == "number" &&
-            !Number.isNaN(value - value) && // NaN-NaN==NaN && Infinity-Infinity==NaN &&  (-Infinity)-(-Infinity)==NaN
-            (!this.isFunction || this.isFunction(value));
     }
+    is = (value) => !!(value && typeof value == "function");
 }
 
 function record(keyType, valueType) {
     return new IslyRecord(keyType, valueType);
 }
-class IslyRecord extends Type {
+class IslyRecord extends TimeZone.Type {
+    keyType;
+    valueType;
+    class = "record";
     constructor(keyType, valueType) {
         super(() => `Record<${keyType.name}, ${valueType.name}>`);
         this.keyType = keyType;
         this.valueType = valueType;
-        this.class = "record";
-        this.is = (value) => !!(value &&
-            typeof value == "object" &&
-            !globalThis.Array.isArray(value) &&
-            globalThis.Object.entries(value).every(([key, value]) => this.keyType.is(this.keyType.name == "number" && `${+key}` == key ? +key : key) && this.valueType.is(value)));
     }
+    is = (value) => !!(value &&
+        typeof value == "object" &&
+        !globalThis.Array.isArray(value) &&
+        globalThis.Object.entries(value).every(([key, value]) => this.keyType.is(this.keyType.name == "number" && `${+key}` == key ? +key : key) && this.valueType.is(value)));
     createFlaw(value) {
         return {
             flaws: value &&
@@ -408,40 +60,17 @@ class IslyRecord extends Type {
     }
 }
 
-function union(...types) {
-    return new IslyUnion(...types);
-}
-class IslyUnion extends Type {
-    constructor(...types) {
-        super(() => types.map(type => type.name).join(" | "));
-        this.class = "union";
-        this.is = (value) => this.types.some(type => type.is(value));
-        this.types = types;
-    }
-    createFlaw(value) {
-        return {
-            flaws: this.types.map(type => type.flaw(value)).filter(flaw => flaw),
-        };
-    }
-    getValue(value) {
-        return this.types.find(type => type.is(value))?.get(value);
-    }
-}
-
 function islyUndefined(name) {
     return new IslyUndefined(name ?? "undefined");
 }
-class IslyUndefined extends Type {
-    constructor() {
-        super(...arguments);
-        this.class = "undefined";
-        this.is = (value) => value === undefined;
-    }
+class IslyUndefined extends TimeZone.Type {
+    class = "undefined";
+    is = (value) => value === undefined;
 }
 
 var Hex;
 (function (Hex) {
-    Hex.type = string(new RegExp(/^#([0-9a-f]{3}|[0-9a-f]{6})$/i));
+    Hex.type = TimeZone.string(new RegExp(/^#([0-9a-f]{3}|[0-9a-f]{6})$/i));
     function toRGB(hex) {
         hex = hex.replace(/^#/, "");
         if (hex.length === 3) {
@@ -461,10 +90,10 @@ var Hex;
 
 var HSL;
 (function (HSL) {
-    HSL.type = object({
-        h: number().optional(),
-        s: number().optional(),
-        l: number().optional(),
+    HSL.type = TimeZone.object({
+        h: TimeZone.number().optional(),
+        s: TimeZone.number().optional(),
+        l: TimeZone.number().optional(),
     });
     function toRGB({ h, s, l }) {
         let r = 0;
@@ -517,10 +146,10 @@ var HSL;
 
 exports.RGB = void 0;
 (function (RGB) {
-    RGB.type = object({
-        r: number().optional(),
-        g: number().optional(),
-        b: number().optional(),
+    RGB.type = TimeZone.object({
+        r: TimeZone.number().optional(),
+        g: TimeZone.number().optional(),
+        b: TimeZone.number().optional(),
     });
     function toHex(rgb) {
         let hex = "";
@@ -594,7 +223,7 @@ exports.Color = void 0;
         "medium",
         "dark",
     ];
-    Color.type = string(Color.types);
+    Color.type = TimeZone.string(Color.types);
     Color.is = Color.type.is;
 })(exports.Color || (exports.Color = {}));
 
@@ -1247,8 +876,8 @@ _Listenable_listeners = new WeakMap();
 
 exports.Data = void 0;
 (function (Data) {
-    Data.valueType = union(string(), number(), boolean(), fromIs("Blob", value => value instanceof Blob), islyUndefined());
-    Data.type = record(string(), union(lazy(() => Data.type, "Data"), Data.valueType));
+    Data.valueType = TimeZone.union(TimeZone.string(), TimeZone.number(), TimeZone.boolean(), fromIs("Blob", value => value instanceof Blob), islyUndefined());
+    Data.type = record(TimeZone.string(), TimeZone.union(TimeZone.lazy(() => Data.type, "Data"), Data.valueType));
     function set(data, [head, ...tail], value) {
         const current = data[head !== null && head !== void 0 ? head : ""];
         return Object.assign(Object.assign({}, data), { [head !== null && head !== void 0 ? head : ""]: !tail.length
@@ -1261,7 +890,7 @@ exports.Data = void 0;
     }
     Data.deepen = deepen;
     function isArrayRecord(d) {
-        return (object().is(d) && (keys => !!keys.length && keys.every(k => parseInt(k).toString() == k))(Object.keys(d)));
+        return (TimeZone.object().is(d) && (keys => !!keys.length && keys.every(k => parseInt(k).toString() == k))(Object.keys(d)));
     }
     function convertArrays(data) {
         return isArrayRecord(data)
@@ -1269,7 +898,7 @@ exports.Data = void 0;
                 arr[k] = convertArrays(v);
                 return arr;
             }, [])
-            : object().is(data) && !(data instanceof Blob || data instanceof File)
+            : TimeZone.object().is(data) && !(data instanceof Blob || data instanceof File)
                 ? Object.fromEntries(Object.entries(data).map(([k, v]) => [k, convertArrays(v)]))
                 : data;
     }
@@ -1303,8 +932,8 @@ exports.Data = void 0;
 exports.Submit = void 0;
 (function (Submit) {
     Submit.types = ["update", "change", "fetch", "create", "remove"];
-    Submit.type = object({
-        type: string(Submit.types).optional(),
+    Submit.type = TimeZone.object({
+        type: TimeZone.string(Submit.types).optional(),
         result: islyFunction(),
         value: exports.Data.type,
     });
@@ -1330,13 +959,8 @@ exports.Scrollable = void 0;
 })(exports.Scrollable || (exports.Scrollable = {}));
 
 exports.Listenable = Listenable;
-exports.Type = Type;
-exports.boolean = boolean;
 exports.fromIs = fromIs;
 exports.islyFunction = islyFunction;
-exports.number = number;
-exports.object = object;
 exports.record = record;
-exports.string = string;
 
-//# sourceMappingURL=Scrollable-a60d6091.js.map
+//# sourceMappingURL=Scrollable-20426515.js.map