@wener/common 1.0.5 → 2.0.1

package/lib/jsonschema/JsonSchema.js

@@ -1,17 +1,18 @@
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
 // import localize from 'ajv-i18n/localize/zh';
-import addKeywords from "ajv-keywords";
-import { isNil } from "es-toolkit";
-import { match, P } from "ts-pattern";
+import addKeywords from 'ajv-keywords';
+import { isNil } from 'es-toolkit';
+import { match, P } from 'ts-pattern';
 function _createAjv(opt) {
-    const ajv = new Ajv(opt);
+    var ajv = new Ajv(opt);
     addKeywords(ajv);
     addFormats(ajv);
     return ajv;
 }
-function validate({ schema, data, mutate, clone, ajv }) {
-    let opts = {
+function validate(param) {
+    var schema = param.schema, data = param.data, mutate = param.mutate, clone = param.clone, ajv = param.ajv;
+    var opts = {
         // strict: 'log',
         strict: true,
         strictSchema: 'log'
@@ -30,13 +31,13 @@ function validate({ schema, data, mutate, clone, ajv }) {
     if (!ajv) {
         ajv = JsonSchema.createAjv(opts);
     }
-    const validate = ajv.compile(schema);
+    var validate = ajv.compile(schema);
     // consider reusing validate instance
-    const valid = validate(data);
-    const errors = validate.errors;
+    var valid = validate(data);
+    var errors = validate.errors;
     // localize(errors);
     return {
-        data,
+        data: data,
         success: valid,
         message: ajv.errorsText(errors),
         errors: errors
@@ -45,22 +46,29 @@ function validate({ schema, data, mutate, clone, ajv }) {
 (function(JsonSchema) {
     JsonSchema.schemas = [];
     JsonSchema.createAjv = _createAjv;
-    function addSchema(schema, { onConflict = 'throw' } = {}) {
+    function addSchema(schema) {
+        var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, _ref_onConflict = _ref.onConflict, onConflict = _ref_onConflict === void 0 ? 'throw' : _ref_onConflict;
         if (!schema.$id) throw new Error('Schema must have $id');
         switch(onConflict){
             case 'ignore':
-                onConflict = (old)=>old;
+                onConflict = function(old) {
+                    return old;
+                };
                 break;
             case 'replace':
-                onConflict = (_, neo)=>neo;
+                onConflict = function(_, neo) {
+                    return neo;
+                };
                 break;
             case 'throw':
-                onConflict = (old, neo)=>{
-                    throw new Error(`Schema ${neo.$id} already exists`);
+                onConflict = function(old, neo) {
+                    throw new Error("Schema ".concat(neo.$id, " already exists"));
                 };
                 break;
         }
-        let idx = JsonSchema.schemas.findIndex((s)=>s.$id === schema.$id);
+        var idx = JsonSchema.schemas.findIndex(function(s) {
+            return s.$id === schema.$id;
+        });
         if (idx >= 0) {
             JsonSchema.schemas[idx] = onConflict(JsonSchema.schemas[idx], schema);
         } else {
@@ -70,8 +78,8 @@ function validate({ schema, data, mutate, clone, ajv }) {
     JsonSchema.addSchema = addSchema;
     function check(schema, data) {
         return validate({
-            schema,
-            data,
+            schema: schema,
+            data: data,
             mutate: false,
             clone: true
         });
@@ -81,8 +89,8 @@ function validate({ schema, data, mutate, clone, ajv }) {
 	 */ JsonSchema.check = check;
     function safeParse(schema, data) {
         return validate({
-            schema,
-            data,
+            schema: schema,
+            data: data,
             mutate: true,
             clone: true
         });
@@ -91,12 +99,12 @@ function validate({ schema, data, mutate, clone, ajv }) {
 	 * Parse data with default value and coerceTypes
 	 */ JsonSchema.safeParse = safeParse;
     function parse(schema, data) {
-        const { data: out, message, errors } = validate({
-            schema,
-            data,
+        var _validate = validate({
+            schema: schema,
+            data: data,
             mutate: true,
             clone: true
-        });
+        }), out = _validate.data, message = _validate.message, errors = _validate.errors;
         if (errors) {
             throw new Error(message);
         }
@@ -106,56 +114,72 @@ function validate({ schema, data, mutate, clone, ajv }) {
     function create(schema, data) {
         // will not ensure value match the rule
         return match(schema).returnType().with({
-            const: P.select()
-        }, (v)=>v).with({
+            const: P.nonNullable
+        }, function(v) {
+            return v;
+        }).with({
             default: P.select()
-        }, (v)=>v).with({
+        }, function(v) {
+            return v;
+        }).with({
             anyOf: P.nonNullable
-        }, (schema)=>{
+        }, function(schema) {
             return create(schema.anyOf[0]);
         }).with({
             oneOf: P.nonNullable
-        }, (schema)=>{
+        }, function(schema) {
             return create(schema.oneOf[0]);
         }).with({
             type: 'string'
-        }, (schema)=>'').with({
+        }, function(schema) {
+            return '';
+        }).with({
             type: P.union('number', 'integer')
-        }, (schema)=>0).with({
+        }, function(schema) {
+            return 0;
+        }).with({
             type: 'object'
-        }, (schema)=>{
-            let out = validate({
-                schema,
-                data: data ?? {},
+        }, function(schema) {
+            var out = validate({
+                schema: schema,
+                data: data !== null && data !== void 0 ? data : {},
                 mutate: true
             });
             if (!out.success) {
+                var _schema_required;
                 // fallback
-                let obj = data || {};
-                schema.required?.forEach((key)=>{
+                var obj = data || {};
+                (_schema_required = schema.required) === null || _schema_required === void 0 ? void 0 : _schema_required.forEach(function(key) {
                     if (!(key in obj)) {
-                        let last = obj[key];
-                        let prop = schema.properties?.[key];
+                        var _schema_properties;
+                        var last = obj[key];
+                        var prop = (_schema_properties = schema.properties) === null || _schema_properties === void 0 ? void 0 : _schema_properties[key];
                         if (prop && isNil(last)) obj[key] = JsonSchema.create(prop, last);
                     }
                 });
                 out = validate({
-                    schema,
+                    schema: schema,
                     data: obj,
                     mutate: true
                 });
                 if (!out.success) {
-                    console.warn(`Failed to create object with schema: ${out.message}`);
+                    console.warn("Failed to create object with schema: ".concat(out.message));
                 }
             }
             return out.data;
         }).with({
             type: 'null'
-        }, ()=>null).with({
+        }, function() {
+            return null;
+        }).with({
             type: 'boolean'
-        }, (schema)=>false).with({
+        }, function(schema) {
+            return false;
+        }).with({
             type: 'array'
-        }, (schema)=>[]).otherwise(()=>{
+        }, function(schema) {
+            return [];
+        }).otherwise(function() {
             return undefined;
         });
     }
@@ -163,18 +187,20 @@ function validate({ schema, data, mutate, clone, ajv }) {
     function isPrimitiveType(schema) {
         return match(schema).returnType().with({
             type: P.union('number', 'integer', 'string', 'boolean')
-        }, ()=>true).with({
+        }, function() {
+            return true;
+        }).with({
             anyOf: P.nonNullable
-        }, (schema)=>{
+        }, function(schema) {
             return isPrimitiveType(schema.anyOf[0]);
         }).with({
             oneOf: P.nonNullable
-        }, (schema)=>{
+        }, function(schema) {
             return isPrimitiveType(schema.oneOf[0]);
-        }).otherwise(()=>false);
+        }).otherwise(function() {
+            return false;
+        });
     }
     JsonSchema.isPrimitiveType = isPrimitiveType;
 })(JsonSchema || (JsonSchema = {}));
 export var JsonSchema;
-
-//# sourceMappingURL=JsonSchema.js.map

package/lib/jsonschema/JsonSchema.test.js

@@ -0,0 +1,137 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr))
+        return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null)
+        return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+            _arr.push(_s.value);
+            if (i && _arr.length === i)
+                break;
+        }
+    }
+    catch (err) {
+        _d = true;
+        _e = err;
+    }
+    finally {
+        try {
+            if (!_n && _i["return"] != null)
+                _i["return"]();
+        }
+        finally {
+            if (_d)
+                throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+import { describe, expect, it } from "vitest";
+import { JsonSchema } from "./JsonSchema.js";
+describe("jsonschema", function () {
+    it("should create from schema", function () {
+        for (var _i = 0, _iter = [
+            [
+                {
+                    type: "string"
+                },
+                ""
+            ],
+            [
+                {
+                    type: "number"
+                },
+                0
+            ],
+            [
+                {
+                    type: "number",
+                    default: 1
+                },
+                1
+            ],
+            [
+                {
+                    type: "integer"
+                },
+                0
+            ],
+            [
+                {
+                    type: "array"
+                },
+                []
+            ],
+            [
+                {
+                    type: "object"
+                },
+                {}
+            ],
+            [
+                {
+                    type: "object",
+                    properties: {
+                        a: {
+                            type: "string"
+                        }
+                    },
+                    required: [
+                        "a"
+                    ]
+                },
+                {
+                    a: ""
+                }
+            ]
+        ]; _i < _iter.length; _i++) {
+            var _iter__i = _sliced_to_array(_iter[_i], 2), a = _iter__i[0], b = _iter__i[1];
+            expect(JsonSchema.create(a)).toEqual(b);
+        }
+    });
+    it("should match typebox types", function () {
+        var a;
+        var b;
+        a = b;
+    });
+    it("should match ajv types", function () {
+        var a;
+        var b;
+        var c;
+        a = b;
+        // a = c;
+    });
+});

package/lib/jsonschema/index.js

@@ -1,2 +1 @@
 export { JsonSchema } from "./JsonSchema.js";
-//# sourceMappingURL=index.js.map

package/lib/jsonschema/types.d.js

@@ -1,3 +1,5 @@
-export { };
-
-//# sourceMappingURL=types.d.js.map
+/**
+ * JSON Schema Definition
+ *
+ * @see https://json-schema.org/specification-links.html
+ */ export { };

package/lib/meta/defineFileType.js

@@ -1,5 +1,91 @@
-let _all = [];
-export function defineFileType({ type = '', types = [], extension = '', extensions = [], ...opts }) {
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var _all = [];
+export function defineFileType(_param) {
+    var _param_type = _param.type, type = _param_type === void 0 ? '' : _param_type, _param_types = _param.types, types = _param_types === void 0 ? [] : _param_types, _param_extension = _param.extension, extension = _param_extension === void 0 ? '' : _param_extension, _param_extensions = _param.extensions, extensions = _param_extensions === void 0 ? [] : _param_extensions, opts = _object_without_properties(_param, [
+        "type",
+        "types",
+        "extension",
+        "extensions"
+    ]);
     if (!type) {
         type = types[0] || '';
     }
@@ -8,30 +94,29 @@ export function defineFileType({ type = '', types = [], extension = '', extensio
     }
     if (!types.includes(type)) {
         types = [
-            type,
-            ...types
-        ];
+            type
+        ].concat(_to_consumable_array(types));
     }
     if (!extensions.includes(extension)) {
         extensions = [
-            extension,
-            ...extensions
-        ];
+            extension
+        ].concat(_to_consumable_array(extensions));
     }
-    const def = {
+    var def = _object_spread({
         title: opts.title || opts.name,
-        type,
-        extension,
-        types,
-        extensions,
+        type: type,
+        extension: extension,
+        types: types,
+        extensions: extensions,
         tags: [],
-        metadata: {},
-        ...opts
-    };
-    let idx = _all.findIndex((v)=>v.name === def.name);
+        metadata: {}
+    }, opts);
+    var idx = _all.findIndex(function(v) {
+        return v.name === def.name;
+    });
     if (idx >= 0) {
         _all[idx] = def;
-        console.warn(`File type ${def.name} is redefined`);
+        console.warn("File type ".concat(def.name, " is redefined"));
     } else {
         _all.push(def);
     }
@@ -40,5 +125,3 @@ export function defineFileType({ type = '', types = [], extension = '', extensio
 export function getFileType() {
     return _all;
 }
-
-//# sourceMappingURL=defineFileType.js.map