smoothly 1.0.0-alpha.218 → 1.0.0-alpha.219

package/dist/cjs/Data-50d47740.js

@@ -0,0 +1,589 @@
+'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 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");
+}
+
+exports.Color = void 0;
+(function (Color) {
+  Color.types = [
+    "default",
+    "primary",
+    "secondary",
+    "tertiary",
+    "success",
+    "warning",
+    "danger",
+    "light",
+    "medium",
+    "dark",
+  ];
+  Color.type = string(Color.types);
+  Color.is = Color.type.is;
+})(exports.Color || (exports.Color = {}));
+
+exports.Icon = void 0;
+(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;
+})(exports.Icon || (exports.Icon = {}));
+
+class Message {
+  static is(value) {
+    return typeof value == "object" && typeof value.destination == "string" && value.content != undefined;
+  }
+  static send(message, content, context) {
+    if (Message.is(message) && context == undefined) {
+      context = content;
+      if (!context)
+        context = window;
+      const destination = message.destination.split("#", 2);
+      message = { destination: destination[1], content: message.content };
+      context.postMessage(message, destination[0]);
+    }
+    else if (typeof context != "string") {
+      if (!context)
+        context = window;
+      if (typeof message == "string")
+        Message.send({ destination: message, content }, context);
+    }
+  }
+  static listen(origin, handle, context) {
+    const splitted = origin.split("#", 2);
+    let destination = "";
+    if (splitted.length == 2) {
+      origin = splitted[0];
+      destination = splitted[1];
+    }
+    (context || window).addEventListener("message", (e) => {
+      const message = e.data;
+      if (Message.is(message) &&
+        (origin == "*" || e.origin == origin) &&
+        (destination == "" || message.destination == destination))
+        handle(message.destination, message.content);
+    });
+  }
+}
+
+class Trigger {
+  static is(value) {
+    return typeof value == "object" && typeof value.name == "string";
+  }
+}
+
+var __classPrivateFieldGet = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Listenable_listeners;
+class Listenable {
+  constructor() {
+    _Listenable_listeners.set(this, {});
+  }
+  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]);
+    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));
+    function getProperties(backend) {
+      return Object.fromEntries(Object.entries(Object.assign(Object.assign({}, Object.getOwnPropertyDescriptors(backend)), Object.getOwnPropertyDescriptors(Object.getPrototypeOf(backend)))).map(([name, descriptor]) => [
+        name,
+        typeof descriptor.value == "function"
+          ? {
+            get() {
+              return backend[name].bind(backend);
+            },
+          }
+          : descriptor.writable || descriptor.set
+            ? {
+              get() {
+                return backend[name];
+              },
+              set(value) {
+                var _a;
+                backend[name] = value;
+                (_a = __classPrivateFieldGet(result, _Listenable_listeners, "f")[name]) === null || _a === void 0 ? void 0 : _a.forEach(listener => listener(backend[name]));
+              },
+            }
+            : {
+              get() {
+                return backend[name];
+              },
+            },
+      ]));
+    }
+  }
+}
+_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));
+  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;
+})(exports.Data || (exports.Data = {}));
+
+exports.Listenable = Listenable;
+exports.Message = Message;
+exports.Trigger = Trigger;
+exports.Type = Type;
+exports.boolean = boolean;
+exports.object = object;
+exports.record = record;
+exports.string = string;
+exports.union = union;
+
+//# sourceMappingURL=Data-50d47740.js.map