smoothly 1.0.0-alpha.21 → 1.0.0-alpha.211

package/dist/esm/{Listenable-fb6f4723.js → Data-0390d600.js}

@@ -45,6 +45,15 @@ function decode(value, standard = "standard") {
     }
     return result;
 }
+function next(value, increment = 1, standard = "standard") {
+    const table = tables[standard];
+    const rest = value.length > 1 ? value.substring(0, value.length - 1) : increment > 0 ? "" : table[63];
+    const number = (value.length == 0 ? 0 : table.indexOf(value[value.length - 1])) + increment;
+    return ((number > 63 || number < 0 ? next(rest, Math.floor(number / 63), standard) : rest) + table[remainder(number, 64)]);
+}
+function remainder(left, right) {
+    return left >= 0 ? left % right : remainder(left + right, right);
+}
 
 const crypto = typeof window != "undefined"
     ? window.crypto || window.msCrypto
@@ -151,6 +160,23 @@ var Identifier;
         return result.join("");
     }
     Identifier.toHexadecimal = toHexadecimal;
+    function min(length) {
+        return "".padStart(length, "A");
+    }
+    Identifier.min = min;
+    function max(length) {
+        return "".padStart(length, "_");
+    }
+    Identifier.max = max;
+    function next$1(identifier, increment = 1) {
+        const result = next(identifier, increment, "url");
+        return result.length == identifier.length ? result : result.substring(result.length - identifier.length);
+    }
+    Identifier.next = next$1;
+    function previous(identifier, decrement = 1) {
+        return next$1(identifier, -decrement);
+    }
+    Identifier.previous = previous;
     Identifier.length = [
         4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, 100, 104, 108, 112,
         116, 120, 124, 128,
@@ -436,7 +462,13 @@ if (!Uint8Array.__proto__.from) {
 var Converter;
 (function (Converter) {
     function is(value) {
-        return typeof value == "object" && Object.entries(value).every(v => typeof v == "function");
+        return (typeof value == "object" &&
+            Object.values(value).every(v => v &&
+                typeof v == "object" &&
+                "forward" in v &&
+                typeof v.forward == "function" &&
+                "backward" in v &&
+                typeof v.backward == "function"));
     }
     Converter.is = is;
 })(Converter || (Converter = {}));
@@ -654,6 +686,451 @@ var Token;
     Token.is = is;
 })(Token || (Token = {}));
 
+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 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
+         */
+        this.get = value => (this.is(value) ? this.getValue(value) : undefined);
+        /**
+         * 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,
+                };
+        };
+    }
+    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.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.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.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));
+    }
+}
+
+class IslyBoolean extends Type {
+    constructor(booleanValue) {
+        super(booleanValue == undefined ? "boolean" : booleanValue ? "true" : "false");
+        this.booleanValue = booleanValue;
+        this.is = (value => typeof value == "boolean" && (this.booleanValue == undefined || value == this.booleanValue));
+    }
+}
+function boolean(booleanValue) {
+    return new IslyBoolean(booleanValue);
+}
+
+class IslyLazy extends Type {
+    constructor(factory, name) {
+        super(name ?? (() => (this.backend ??= factory()).name), () => (this.backend ??= factory()).condition);
+        this.factory = factory;
+        this.is = (value => (this.backend ??= this.factory()).is(value));
+        this.get = value => this.backend.get(value);
+    }
+    createFlaw(value) {
+        return this.createFlawFromType((this.backend ??= this.factory()), value);
+    }
+}
+/**
+ * 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 IslyObject extends Type {
+    constructor(baseType, properties, name) {
+        super(() => name ??
+            (this.baseType ? `${this.baseType.name} & ` : "") +
+                `{${globalThis.Object.entries(this.properties)
+                    .map(([property, type]) => `${property}: ${type.name}`)
+                    .join(", ")}}`);
+        this.baseType = baseType;
+        this.properties = properties;
+        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(this, properties, name);
+    }
+    omit(omits, name) {
+        return new IslyObject(this.baseType?.omit(omits), globalThis.Object.fromEntries(globalThis.Object.entries(this.properties).filter(([key]) => !omits.includes(key))), name ?? `Omit<${this.name}, ${omits.map(key => `"${String(key)}"`).join(" | ")}>`);
+    }
+    pick(picks, name) {
+        return new IslyObject(this.baseType?.pick(picks), globalThis.Object.fromEntries(globalThis.Object.entries(this.properties).filter(([key]) => picks.includes(key))), name ?? `Pick<${this.name}, ${picks.map(key => `"${String(key)}"`).join(" | ")}>`);
+    }
+    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;
+    }
+}
+function object(properties, name) {
+    return new IslyObject(undefined, properties ?? {}, name);
+}
+
+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.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);
+    }
+}
+function string(condition) {
+    return new IslyString(condition);
+}
+
+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 = {}));
+
+class IslyFromIs extends Type {
+    constructor(name, isFunction) {
+        super(name);
+        this.isFunction = isFunction;
+        this.is = (value => this.isFunction(value));
+    }
+}
+function fromIs(name, is) {
+    return new IslyFromIs(name, is);
+}
+
+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",
+    },
+};
+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.is = (value => typeof value == "number" &&
+            !Number.isNaN(value - value) && // NaN-NaN==NaN && Infinity-Infinity==NaN &&  (-Infinity)-(-Infinity)==NaN
+            (!this.isFunction || this.isFunction(value)));
+    }
+}
+/**
+ * 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);
+}
+
+class IslyRecord extends Type {
+    constructor(keyType, valueType) {
+        super(() => `Record<${keyType.name}, ${valueType.name}>`);
+        this.keyType = keyType;
+        this.valueType = valueType;
+        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))));
+    }
+    createFlaw(value) {
+        return {
+            flaws: value &&
+                typeof value == "object" &&
+                !globalThis.Array.isArray(value) &&
+                globalThis.Object.entries(value).flatMap(([key, propertyValue]) => [
+                    this.keyType.flaw(this.keyType.name == "number" && `${+key}` == key ? +key : key),
+                    this.valueType.flaw(propertyValue),
+                ]
+                    .map((flaw, index) => (flaw.isFlaw ?? true) && { property: key + ` (${["key", "value"][index]})`, ...flaw })
+                    .filter(Boolean)),
+        };
+    }
+    getValue(value) {
+        return globalThis.Object.fromEntries(globalThis.Object.entries(value).map(([key, value]) => [key, this.valueType.get(value)]));
+    }
+}
+function record(keyType, valueType) {
+    return new IslyRecord(keyType, valueType);
+}
+
+class IslyUnion extends Type {
+    constructor(...types) {
+        super(() => types.map(type => type.name).join(" | "));
+        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 union(...types) {
+    return new IslyUnion(...types);
+}
+
+class IslyUndefined extends Type {
+    constructor() {
+        super(...arguments);
+        this.is = (value => value === undefined);
+    }
+}
+function islyUndefined(name) {
+    return new IslyUndefined(name ?? "undefined");
+}
+
+var Color;
+(function (Color) {
+  Color.types = [
+    "default",
+    "primary",
+    "secondary",
+    "tertiary",
+    "success",
+    "warning",
+    "danger",
+    "light",
+    "medium",
+    "dark",
+  ];
+  Color.type = string(Color.types);
+  Color.is = Color.type.is;
+})(Color || (Color = {}));
+
+var Icon;
+(function (Icon) {
+  const names = {
+    "*": "https://ionicons.pages.dev/svg/${name}.svg",
+  };
+  const cache = {};
+  async function fetch(url) {
+    const response = await globalThis.fetch(url);
+    return response.ok ? response.text() : undefined;
+  }
+  async function load(name) {
+    var _a, _b;
+    const url = ((_a = names[name]) !== null && _a !== void 0 ? _a : names["*"]).replace("${name}", name);
+    return (_b = cache[url]) !== null && _b !== void 0 ? _b : (cache[url] = fetch(url));
+  }
+  Icon.load = load;
+  function add(url, ...name) {
+    for (const n of name)
+      names[n] = url;
+  }
+  Icon.add = add;
+})(Icon || (Icon = {}));
+
 class Message {
   static is(value) {
     return typeof value == "object" && typeof value.destination == "string" && value.content != undefined;
@@ -707,16 +1184,29 @@ class Listenable {
   constructor() {
     _Listenable_listeners.set(this, {});
   }
-  listen(property, listener) {
+  listen(property, listener, options) {
     var _a, _b;
     (_b = (_a = __classPrivateFieldGet(this, _Listenable_listeners, "f")[property]) === null || _a === void 0 ? void 0 : _a.push(listener)) !== null && _b !== void 0 ? _b : (__classPrivateFieldGet(this, _Listenable_listeners, "f")[property] = [listener]);
-    listener(this[property]);
+    if (!(options === null || options === void 0 ? void 0 : options.lazy))
+      listener(this[property]);
   }
   unlisten(property, listener) {
     var _a, _b;
     const index = (_a = __classPrivateFieldGet(this, _Listenable_listeners, "f")[property]) === null || _a === void 0 ? void 0 : _a.indexOf(listener);
     index != undefined && index >= 0 && ((_b = __classPrivateFieldGet(this, _Listenable_listeners, "f")[property]) === null || _b === void 0 ? void 0 : _b.splice(index, 1));
   }
+  batchListen(listeners, options) {
+    for (const key in listeners) {
+      const listener = listeners[key];
+      listener && this.listen(key, listener, options);
+    }
+  }
+  batchUnlisten(listeners) {
+    for (const key in listeners) {
+      const listener = listeners[key];
+      listener && this.unlisten(key, listener);
+    }
+  }
   static load(backend) {
     const result = backend.listenable;
     return Object.defineProperties(result, getProperties(backend));
@@ -737,12 +1227,12 @@ class Listenable {
               set(value) {
                 var _a;
                 backend[name] = value;
-                (_a = __classPrivateFieldGet(result, _Listenable_listeners, "f")[name]) === null || _a === void 0 ? void 0 : _a.forEach(listener => listener(value));
+                (_a = __classPrivateFieldGet(result, _Listenable_listeners, "f")[name]) === null || _a === void 0 ? void 0 : _a.forEach(listener => listener(backend[name]));
               },
             }
             : {
               get() {
-                return backend[name].bind(backend);
+                return backend[name];
               },
             },
       ]));
@@ -751,6 +1241,27 @@ class Listenable {
 }
 _Listenable_listeners = new WeakMap();
 
-export { Identifier as I, Listenable as L, Message as M, Trigger as T };
+var Data;
+(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));
+  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
+        ? value
+        : set(typeof current == "object" && !(current instanceof Blob) ? current : {}, tail, value) });
+  }
+  Data.set = set;
+  function deepen(data) {
+    return merge({}, data);
+  }
+  Data.deepen = deepen;
+  function merge(data, changes) {
+    return Object.entries(changes).reduce((r, [name, value]) => set(r, name.split("."), value), data);
+  }
+  Data.merge = merge;
+})(Data || (Data = {}));
+
+export { Color as C, Data as D, Identifier as I, Listenable as L, Message as M, Trigger as T, Icon as a, Type as b, boolean as c, object as o, record as r, string as s, union as u };
 
-//# sourceMappingURL=Listenable-fb6f4723.js.map
+//# sourceMappingURL=Data-0390d600.js.map