@wener/common 1.0.4 → 2.0.1

package/lib/tools/generateSchema.js

@@ -0,0 +1,201 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { exec } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as Codegen from '@sinclair/typebox-codegen';
+export function generateSchema(_0) {
+    return _async_to_generator(function(param) {
+        var file, _param_dir, dir, fn, types, typeboxDir, zodDir, typeBoxFile, zodFile, out, model;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    file = param.file, _param_dir = param.dir, dir = _param_dir === void 0 ? path.dirname(file) : _param_dir;
+                    fn = path.basename(file).replace(/\.d\.ts$/, '.ts');
+                    return [
+                        4,
+                        fs.readFile(file, 'utf-8')
+                    ];
+                case 1:
+                    types = _state.sent();
+                    typeboxDir = path.join(dir, 'typebox');
+                    zodDir = path.join(dir, 'zod');
+                    return [
+                        4,
+                        fs.mkdir(typeboxDir, {
+                            recursive: true
+                        })
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        4,
+                        fs.mkdir(zodDir, {
+                            recursive: true
+                        })
+                    ];
+                case 3:
+                    _state.sent();
+                    typeBoxFile = path.join(typeboxDir, fn);
+                    zodFile = path.join(zodDir, fn);
+                    // avoid import type error
+                    out = Codegen.TypeScriptToTypeBox.Generate(types);
+                    out = out.replace(/^import \{ Type, Static\b/, "import { Type, type Static");
+                    return [
+                        4,
+                        fs.writeFile(typeBoxFile, out)
+                    ];
+                case 4:
+                    _state.sent();
+                    model = Codegen.TypeScriptToModel.Generate(types);
+                    return [
+                        4,
+                        fs.writeFile(zodFile, Codegen.ModelToZod.Generate(model))
+                    ];
+                case 5:
+                    _state.sent();
+                    return [
+                        4,
+                        new Promise(function(resolve, reject) {
+                            exec('pnpm prettier --write "'.concat(dir, '/{typebox,zod}/*.ts"'), function(error, stdout, stderr) {
+                                if (error) {
+                                    console.error("exec error: ".concat(error));
+                                    reject(error);
+                                    return;
+                                }
+                                resolve({
+                                    stderr: stderr,
+                                    stdout: stdout
+                                });
+                                stdout && console.log("prettier:stdout: ".concat(stdout));
+                                stderr && console.error("prettier:stderr: ".concat(stderr));
+                            });
+                        })
+                    ];
+                case 6:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}

package/lib/tools/renderJsonSchemaToMarkdownDoc.js

@@ -1,85 +1,173 @@
+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);
+}
 export function renderJsonSchemaToMarkdownDoc(rootSchema) {
     // markdown
-    const out = [];
-    const all = new Set();
-    const pending = [];
-    const addObject = (o)=>{
+    var out = [];
+    var all = new Set();
+    var pending = [];
+    var addObject = function(o) {
         if (all.has(o.$id)) {
             return;
         }
         all.add(o.$id);
         pending.push(o);
     };
-    const writeObjectProps = (T, { prefix = '' } = {})=>{
-        if (!T?.properties) {
+    var writeObjectProps = function(T) {
+        var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, _ref_prefix = _ref.prefix, prefix = _ref_prefix === void 0 ? '' : _ref_prefix;
+        if (!(T === null || T === void 0 ? void 0 : T.properties)) {
             return;
         }
-        for (const [name, schema] of Object.entries(T.properties)){
-            let typ = schema.$id || schema.type;
-            if (typ === 'array') {
-                typ = `${schema.items.$id || schema.items.type}[]`;
-                if (schema.items.$id) {
-                    addObject(schema.items);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = Object.entries(T.properties)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], schema = _step_value[1];
+                var typ = schema.$id || schema.type;
+                if (typ === 'array') {
+                    typ = "".concat(schema.items.$id || schema.items.type, "[]");
+                    if (schema.items.$id) {
+                        addObject(schema.items);
+                    }
+                } else if (schema.$id) {
+                    addObject(schema);
                 }
-            } else if (schema.$id) {
-                addObject(schema);
-            }
-            if (!typ) {
-                if ('anyOf' in schema) {
-                    typ = 'enum';
+                if (!typ) {
+                    if ('anyOf' in schema) {
+                        typ = 'enum';
+                    }
                 }
-            }
-            out.push(`| ${prefix}${name} | ${typ} | ${schema.title || schema.description || ''} |`);
-            if (typ === 'object') {
-                writeObjectProps(schema, {
-                    prefix: `${prefix}${name}.`
-                });
-            } else if (schema.type === 'array') {
-                if (schema.items.type === 'object' && !schema.items.$id) {
-                    writeObjectProps(schema.items, {
-                        prefix: `${prefix}${name}[].`
+                out.push("| ".concat(prefix).concat(name, " | ").concat(typ, " | ").concat(schema.title || schema.description || '', " |"));
+                if (typ === 'object') {
+                    writeObjectProps(schema, {
+                        prefix: "".concat(prefix).concat(name, ".")
                     });
+                } else if (schema.type === 'array') {
+                    if (schema.items.type === 'object' && !schema.items.$id) {
+                        writeObjectProps(schema.items, {
+                            prefix: "".concat(prefix).concat(name, "[].")
+                        });
+                    }
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
                 }
             }
         }
     };
-    const writeObject = (T)=>{
-        out.push(`### ${T.title || T.$id}`);
-        out.push(`
-| $id | 名字 |
-| --- | --- |
-| ${T.$id || ''} | ${T.title || ''} | 
-    `);
+    var writeObject = function(T) {
+        out.push("### ".concat(T.title || T.$id));
+        out.push("\n| $id | 名字 |\n| --- | --- |\n| ".concat(T.$id || '', " | ").concat(T.title || '', " | \n    "));
         if (T.description) {
             out.push('');
-            out.push(`> ${T.description}`);
+            out.push("> ".concat(T.description));
             out.push('');
         }
-        out.push(`| 名字 | 类型 | 说明 |`);
-        out.push(`| --- | --- | --- |`);
+        out.push("| 名字 | 类型 | 说明 |");
+        out.push("| --- | --- | --- |");
         writeObjectProps(T);
         out.push('');
     };
     writeObject(rootSchema);
-    for (const schema of pending){
-        if (schema.type === 'object') {
-            writeObject(schema);
-        } else if ('anyOf' in schema) {
-            out.push(`### ${schema.$id || schema.title}`);
-            out.push(`
-| $id | 名字 |
-| --- | --- |
-| ${schema.$id || ''} | ${schema.title || ''} | 
-    `);
-            out.push(`| 值 |  说明 |`);
-            out.push(`| --- | --- |`);
-            for (const item of schema.anyOf){
-                out.push(`| ${item.const} | ${item.title || item.description || ''} |`);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = pending[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var schema = _step.value;
+            if (schema.type === 'object') {
+                writeObject(schema);
+            } else if ('anyOf' in schema) {
+                out.push("### ".concat(schema.$id || schema.title));
+                out.push("\n| $id | 名字 |\n| --- | --- |\n| ".concat(schema.$id || '', " | ").concat(schema.title || '', " | \n    "));
+                out.push("| 值 |  说明 |");
+                out.push("| --- | --- |");
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                try {
+                    for(var _iterator1 = schema.anyOf[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var item = _step1.value;
+                        out.push("| ".concat(item.const, " | ").concat(item.title || item.description || '', " |"));
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                }
+                out.push('');
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
             }
-            out.push('');
         }
     }
     return out.join('\n');
 }
-
-//# sourceMappingURL=renderJsonSchemaToMarkdownDoc.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wener/common",
-  "version": "1.0.4",
+  "version": "2.0.1",
   "type": "module",
   "description": "",
   "author": "",
@@ -14,6 +14,10 @@
       "types": "./src/cn/index.ts",
       "default": "./lib/cn/index.js"
     },
+    "./consola": {
+      "types": "./src/consola/index.ts",
+      "default": "./lib/consola/index.js"
+    },
     "./data": {
       "types": "./src/data/index.ts",
       "default": "./lib/data/index.js"
@@ -30,6 +34,14 @@
       "types": "./src/password/index.ts",
       "default": "./lib/password/index.js"
     },
+    "./resource": {
+      "types": "./src/resource/index.ts",
+      "default": "./lib/resource/index.js"
+    },
+    "./schema": {
+      "types": "./src/schema/index.ts",
+      "default": "./lib/schema/index.js"
+    },
     "./search": {
       "types": "./src/search/index.ts",
       "default": "./lib/search/index.js"
@@ -43,25 +55,34 @@
     "src"
   ],
   "keywords": [],
+  "peerDependencies": {
+    "zod": "*"
+  },
   "dependencies": {
-    "es-toolkit": "^1.32.0",
-    "ts-pattern": "^5.6.2",
-    "zod": "^3.24.2",
-    "@wener/utils": "1.1.51"
+    "@standard-schema/spec": "^1.0.0",
+    "@wener/utils": "^1.1.51",
+    "date-fns": "^4.1.0",
+    "es-toolkit": "^1.37.2",
+    "std-env": "^3.9.0",
+    "ts-pattern": "^5.7.0"
   },
   "devDependencies": {
-    "@sinclair/typebox": "^0.34.28",
+    "@sinclair/typebox": "^0.34.33",
+    "@sinclair/typebox-codegen": "^0.11.1",
     "@types/argon2-browser": "^1.18.4",
     "@types/bcrypt": "^5.0.2",
-    "@types/bcryptjs": "^2.4.6",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "ajv-i18n": "^4.2.0",
     "ajv-keywords": "^5.1.0",
-    "argon2": "^0.41.1",
+    "argon2": "^0.43.0",
     "argon2-browser": "^1.18.0",
     "bcrypt": "^5.1.1",
-    "bcryptjs": "^3.0.2"
+    "bcryptjs": "^3.0.2",
+    "chalk": "^5.4.1",
+    "consola": "^3.4.2",
+    "dayjs": "^1.11.13",
+    "zod": "^3.25.63"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/consola/createStandardConsolaReporter.ts

@@ -0,0 +1,31 @@
+import type { ConsolaOptions, ConsolaReporter, LogObject } from 'consola/core';
+import { formatLogObject } from './formatLogObject';
+
+type Formatter = (
+	o: LogObject,
+	ctx: {
+		options: ConsolaOptions;
+	},
+) => string;
+
+export function createStandardConsolaReporter({
+	format = formatLogObject,
+}: {
+	format?: Formatter;
+} = {}): ConsolaReporter {
+	return {
+		log: (o, ctx) => {
+			let out = format(o, ctx);
+			let fn = console.log;
+
+			const { level } = o;
+			if (level < 1) {
+				fn = console.error;
+			} else if (level === 1) {
+				fn = console.warn;
+			}
+
+			fn(out);
+		},
+	};
+}