@wener/common 2.0.5 → 2.0.6

package/lib/schema/validate.js

@@ -1,112 +1,121 @@
-import { Kind as TypeBoxKind } from "@sinclair/typebox";
-import "@sinclair/typebox";
-import { TypeCompiler } from "@sinclair/typebox/compiler";
-import { ifPresent } from "@wener/utils";
-import { Ajv } from "ajv";
-import addFormats from "ajv-formats";
+import { Kind as TypeBoxKind } from '@sinclair/typebox';
+import '@sinclair/typebox';
+import { TypeCompiler } from '@sinclair/typebox/compiler';
+import { ifPresent } from '@wener/utils';
+import { Ajv } from 'ajv';
+import addFormats from 'ajv-formats';
 /*
 https://github.com/react-hook-form/resolvers
 https://github.com/decs/typeschema/tree/main/packages
 */ export function validate(schema, data) {
-    if (isZodSchema(schema)) {
-        const result = schema.safeParse(data);
-        if (result.success) {
-            return {
-                success: true,
-                data: result.data
-            };
-        }
-        return {
-            issues: result.error.issues.map(({ message, path, code })=>({
-                    message,
-                    path,
-                    code
-                })),
-            // message: z.prettifyError(result.error),
-            success: false
-        };
-    }
-    if (isTypeBoxSchema(schema)) {
-        const checker = TypeCompiler.Compile(schema);
-        if (checker.Check(data)) {
-            return {
-                success: true,
-                data: data
-            };
-        }
-        return {
-            issues: Array.from(checker.Errors(data)).map(({ message, path })=>{
-                return {
-                    message,
-                    path: [
-                        path
-                    ]
-                };
-            }),
-            // message: '',
-            success: false
-        };
-    }
-    if (isJsonSchema(schema)) {
-        const ajv = new Ajv({
-            allErrors: true,
-            validateSchema: true
-        });
-        addFormats(ajv);
-        const validator = ajv.compile(schema);
-        if (validator(data)) {
-            return {
-                data: data,
-                success: true
-            };
-        }
-        const issues = validator.errors?.map((error)=>{
-            const message = error.message || 'Unknown error';
-            const path = error.instancePath.split('/').filter(Boolean).map((p)=>p);
-            return {
-                message,
-                path
-            };
-        }) || [];
-        return {
-            success: false,
-            // message: 'Invalid data',
-            issues
-        };
-    }
-    return {
-        success: false,
-        // message: 'Invalid schema',
-        issues: [
-            {
-                message: 'Unknown schema type'
-            }
-        ]
-    };
+	if (isZodSchema(schema)) {
+		const result = schema.safeParse(data);
+		if (result.success) {
+			return {
+				success: true,
+				data: result.data,
+			};
+		}
+		return {
+			issues: result.error.issues.map(({ message, path, code }) => ({
+				message,
+				path,
+				code,
+			})),
+			// message: z.prettifyError(result.error),
+			success: false,
+		};
+	}
+	if (isTypeBoxSchema(schema)) {
+		const checker = TypeCompiler.Compile(schema);
+		if (checker.Check(data)) {
+			return {
+				success: true,
+				data: data,
+			};
+		}
+		return {
+			issues: Array.from(checker.Errors(data)).map(({ message, path }) => {
+				return {
+					message,
+					path: [path],
+				};
+			}),
+			// message: '',
+			success: false,
+		};
+	}
+	if (isJsonSchema(schema)) {
+		const ajv = new Ajv({
+			allErrors: true,
+			validateSchema: true,
+		});
+		addFormats(ajv);
+		const validator = ajv.compile(schema);
+		if (validator(data)) {
+			return {
+				data: data,
+				success: true,
+			};
+		}
+		const issues =
+			validator.errors?.map((error) => {
+				const message = error.message || 'Unknown error';
+				const path = error.instancePath
+					.split('/')
+					.filter(Boolean)
+					.map((p) => p);
+				return {
+					message,
+					path,
+				};
+			}) || [];
+		return {
+			success: false,
+			// message: 'Invalid data',
+			issues,
+		};
+	}
+	return {
+		success: false,
+		// message: 'Invalid schema',
+		issues: [
+			{
+				message: 'Unknown schema type',
+			},
+		],
+	};
 }
 export function parseData(schema, data) {
-    let result = validate(schema, data);
-    if (result.success) {
-        return result.data;
-    }
-    throw Object.assign(new Error(result.issues.map((v)=>{
-        return `${ifPresent(v.path?.join(), (v)=>`[${v}]`)}: ${v.message}`;
-    }).join('; ')), {
-        issues: result.issues
-    });
+	let result = validate(schema, data);
+	if (result.success) {
+		return result.data;
+	}
+	throw Object.assign(
+		new Error(
+			result.issues
+				.map((v) => {
+					return `${ifPresent(v.path?.join(), (v) => `[${v}]`)}: ${v.message}`;
+				})
+				.join('; '),
+		),
+		{
+			issues: result.issues,
+		},
+	);
 }
 function _formatIssues(_schema, _issues) {
-    return '';
+	return '';
 }
 export function isZodSchema(schema) {
-    return typeof schema === 'object' && 'parse' in schema;
+	return typeof schema === 'object' && 'parse' in schema;
 }
 export function isTypeBoxSchema(schema) {
-    return typeof schema === 'object' && TypeBoxKind in schema;
+	return typeof schema === 'object' && TypeBoxKind in schema;
 }
 export function isJsonSchema(schema) {
-    let sc = schema;
-    return typeof schema === 'object' && Boolean(sc.type || sc.properties || sc.anyOf || sc.oneOf || sc.$ref || sc.items);
+	let sc = schema;
+	return typeof schema === 'object' && Boolean(sc.type || sc.properties || sc.anyOf || sc.oneOf || sc.$ref || sc.items);
 }
 
-//# sourceMappingURL=validate.js.map
+//# sourceMappingURL=validate.js.map

package/lib/tools/generateSchema.js

@@ -1,43 +1,43 @@
-import { exec } from "node:child_process";
-import fs from "node:fs/promises";
-import path from "node:path";
-import * as Codegen from "@sinclair/typebox-codegen";
+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 async function generateSchema({ file, dir = path.dirname(file) }) {
-    const fn = path.basename(file).replace(/\.d\.ts$/, '.ts');
-    const types = await fs.readFile(file, 'utf-8');
-    const typeboxDir = path.join(dir, 'typebox');
-    const zodDir = path.join(dir, 'zod');
-    await fs.mkdir(typeboxDir, {
-        recursive: true
-    });
-    await fs.mkdir(zodDir, {
-        recursive: true
-    });
-    const typeBoxFile = path.join(typeboxDir, fn);
-    const zodFile = path.join(zodDir, fn);
-    {
-        // avoid import type error
-        let out = Codegen.TypeScriptToTypeBox.Generate(types);
-        out = out.replace(/^import \{ Type, Static\b/, `import { Type, type Static`);
-        await fs.writeFile(typeBoxFile, out);
-    }
-    const model = Codegen.TypeScriptToModel.Generate(types);
-    await fs.writeFile(zodFile, Codegen.ModelToZod.Generate(model));
-    await new Promise((resolve, reject)=>{
-        exec(`pnpm prettier --write "${dir}/{typebox,zod}/*.ts"`, (error, stdout, stderr)=>{
-            if (error) {
-                console.error(`exec error: ${error}`);
-                reject(error);
-                return;
-            }
-            resolve({
-                stderr,
-                stdout
-            });
-            stdout && console.log(`prettier:stdout: ${stdout}`);
-            stderr && console.error(`prettier:stderr: ${stderr}`);
-        });
-    });
+	const fn = path.basename(file).replace(/\.d\.ts$/, '.ts');
+	const types = await fs.readFile(file, 'utf-8');
+	const typeboxDir = path.join(dir, 'typebox');
+	const zodDir = path.join(dir, 'zod');
+	await fs.mkdir(typeboxDir, {
+		recursive: true,
+	});
+	await fs.mkdir(zodDir, {
+		recursive: true,
+	});
+	const typeBoxFile = path.join(typeboxDir, fn);
+	const zodFile = path.join(zodDir, fn);
+	{
+		// avoid import type error
+		let out = Codegen.TypeScriptToTypeBox.Generate(types);
+		out = out.replace(/^import \{ Type, Static\b/, `import { Type, type Static`);
+		await fs.writeFile(typeBoxFile, out);
+	}
+	const model = Codegen.TypeScriptToModel.Generate(types);
+	await fs.writeFile(zodFile, Codegen.ModelToZod.Generate(model));
+	await new Promise((resolve, reject) => {
+		exec(`pnpm prettier --write "${dir}/{typebox,zod}/*.ts"`, (error, stdout, stderr) => {
+			if (error) {
+				console.error(`exec error: ${error}`);
+				reject(error);
+				return;
+			}
+			resolve({
+				stderr,
+				stdout,
+			});
+			stdout && console.log(`prettier:stdout: ${stdout}`);
+			stderr && console.error(`prettier:stderr: ${stderr}`);
+		});
+	});
 }
 
-//# sourceMappingURL=generateSchema.js.map
+//# sourceMappingURL=generateSchema.js.map

package/lib/tools/renderJsonSchemaToMarkdownDoc.js

@@ -1,85 +1,85 @@
 export function renderJsonSchemaToMarkdownDoc(rootSchema) {
-    // markdown
-    const out = [];
-    const all = new Set();
-    const pending = [];
-    const addObject = (o)=>{
-        if (all.has(o.$id)) {
-            return;
-        }
-        all.add(o.$id);
-        pending.push(o);
-    };
-    const writeObjectProps = (T, { prefix = '' } = {})=>{
-        if (!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);
-                }
-            } else if (schema.$id) {
-                addObject(schema);
-            }
-            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}[].`
-                    });
-                }
-            }
-        }
-    };
-    const writeObject = (T)=>{
-        out.push(`### ${T.title || T.$id}`);
-        out.push(`
+	// markdown
+	const out = [];
+	const all = new Set();
+	const pending = [];
+	const addObject = (o) => {
+		if (all.has(o.$id)) {
+			return;
+		}
+		all.add(o.$id);
+		pending.push(o);
+	};
+	const writeObjectProps = (T, { prefix = '' } = {}) => {
+		if (!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);
+				}
+			} else if (schema.$id) {
+				addObject(schema);
+			}
+			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}[].`,
+					});
+				}
+			}
+		}
+	};
+	const writeObject = (T) => {
+		out.push(`### ${T.title || T.$id}`);
+		out.push(`
 | $id | 名字 |
 | --- | --- |
 | ${T.$id || ''} | ${T.title || ''} | 
     `);
-        if (T.description) {
-            out.push('');
-            out.push(`> ${T.description}`);
-            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(`
+		if (T.description) {
+			out.push('');
+			out.push(`> ${T.description}`);
+			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 || ''} |`);
-            }
-            out.push('');
-        }
-    }
-    return out.join('\n');
+			out.push(`| 值 |  说明 |`);
+			out.push(`| --- | --- |`);
+			for (const item of schema.anyOf) {
+				out.push(`| ${item.const} | ${item.title || item.description || ''} |`);
+			}
+			out.push('');
+		}
+	}
+	return out.join('\n');
 }
 
-//# sourceMappingURL=renderJsonSchemaToMarkdownDoc.js.map
+//# sourceMappingURL=renderJsonSchemaToMarkdownDoc.js.map

package/lib/utils/buildBaseUrl.js

@@ -1,13 +1,13 @@
 function joinUrl(baseUrl, maybeUrl) {
-    const sanitizedBase = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
-    const sanitizedEndpoint = maybeUrl.startsWith('/') ? maybeUrl.slice(1) : maybeUrl;
-    return `${sanitizedBase}/${sanitizedEndpoint}`;
+	const sanitizedBase = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+	const sanitizedEndpoint = maybeUrl.startsWith('/') ? maybeUrl.slice(1) : maybeUrl;
+	return `${sanitizedBase}/${sanitizedEndpoint}`;
 }
 export function buildBaseUrl(url, baseUrl) {
-    if (!baseUrl || /^https?:/.test(url)) {
-        return url;
-    }
-    return joinUrl(baseUrl, url);
+	if (!baseUrl || /^https?:/.test(url)) {
+		return url;
+	}
+	return joinUrl(baseUrl, url);
 }
 
-//# sourceMappingURL=buildBaseUrl.js.map
+//# sourceMappingURL=buildBaseUrl.js.map

package/lib/utils/buildRedactorFormSchema.js

@@ -1,59 +1,60 @@
-import { forEachJsonSchema } from "../jsonschema/index.js";
-import { toJsonSchema } from "../schema/index.js";
-export const RedactedText = "[redacted]";
-export function buildRedactorFormSchema(ts, { shouldRedact = (schema) => schema["x-sensitive"] === true, replacer = () => RedactedText }) {
-    let js = toJsonSchema(ts);
-    let paths = [];
-    forEachJsonSchema(js, (js, { path }) => {
-        if (shouldRedact(js)) {
-            paths.push(path);
-        }
-    });
-    const vis = (root, path) => {
-        switch (root) {
-            case null:
-            case undefined:
-                return;
-        }
-        let c = root;
-        for (let i = 0; i < path.length; i++) {
-            let k = path[i];
-            if (c && typeof c === "object" && k in c) {
-                let v = c[k];
-                if (path.length === 1) {
-                    c[k] = replacer(k, v);
-                }
-                else if (Array.isArray(v)) {
-                    for (let vv of v) {
-                        vis(vv, path.slice(i + 1));
-                    }
-                }
-                else {
-                    vis(v, path.slice(i + 1));
-                }
-            }
-        }
-    };
-    return (root) => {
-        if (!paths.length) {
-            return root;
-        }
-        paths.forEach((path) => {
-            vis(root, path);
-        });
-        return root;
-    };
+import { forEachJsonSchema } from '../jsonschema/index.js';
+import { toJsonSchema } from '../schema/index.js';
+export const RedactedText = '[redacted]';
+export function buildRedactorFormSchema(
+	ts,
+	{ shouldRedact = (schema) => schema['x-sensitive'] === true, replacer = () => RedactedText },
+) {
+	let js = toJsonSchema(ts);
+	let paths = [];
+	forEachJsonSchema(js, (js, { path }) => {
+		if (shouldRedact(js)) {
+			paths.push(path);
+		}
+	});
+	const vis = (root, path) => {
+		switch (root) {
+			case null:
+			case undefined:
+				return;
+		}
+		let c = root;
+		for (let i = 0; i < path.length; i++) {
+			let k = path[i];
+			if (c && typeof c === 'object' && k in c) {
+				let v = c[k];
+				if (path.length === 1) {
+					c[k] = replacer(k, v);
+				} else if (Array.isArray(v)) {
+					for (let vv of v) {
+						vis(vv, path.slice(i + 1));
+					}
+				} else {
+					vis(v, path.slice(i + 1));
+				}
+			}
+		}
+	};
+	return (root) => {
+		if (!paths.length) {
+			return root;
+		}
+		paths.forEach((path) => {
+			vis(root, path);
+		});
+		return root;
+	};
 }
 function _buildReversibleRedactText({ id, type: _type, key: _key, timestamp } = {}) {
-    if (!id) {
-        return RedactedText;
-    }
-    if (timestamp === true) {
-        timestamp = Date.now();
-    }
-    return `[redacted ${id}]`;
+	if (!id) {
+		return RedactedText;
+	}
+	if (timestamp === true) {
+		timestamp = Date.now();
+	}
+	return `[redacted ${id}]`;
 }
 export function isRedactedText(v) {
-    return v === RedactedText || typeof v === "string" && v.startsWith("[redacted ") && v.endsWith("]");
+	return v === RedactedText || (typeof v === 'string' && v.startsWith('[redacted ') && v.endsWith(']'));
 }
 //# sourceMappingURL=buildRedactorFormSchema.js.map

package/lib/utils/getEstimateProcessTime.js

@@ -1,21 +1,26 @@
-export function getEstimateProcessTime({ total, processed, startTime, elapsed = startTime ? (Date.now() - startTime.getTime()) / 1000 : undefined }) {
-    if (typeof total !== 'number' || typeof processed !== 'number' || !elapsed || processed === 0 || processed >= total) {
-        return undefined;
-    }
-    const now = new Date();
-    const rate = processed / elapsed;
-    if (rate === 0) {
-        return undefined;
-    }
-    const remaining = total - processed;
-    const eta = Math.round(remaining / rate);
-    const endTime = new Date(now.getTime() + eta * 1000);
-    return {
-        eta,
-        elapsed,
-        endTime,
-        rate
-    };
+export function getEstimateProcessTime({
+	total,
+	processed,
+	startTime,
+	elapsed = startTime ? (Date.now() - startTime.getTime()) / 1000 : undefined,
+}) {
+	if (typeof total !== 'number' || typeof processed !== 'number' || !elapsed || processed === 0 || processed >= total) {
+		return undefined;
+	}
+	const now = new Date();
+	const rate = processed / elapsed;
+	if (rate === 0) {
+		return undefined;
+	}
+	const remaining = total - processed;
+	const eta = Math.round(remaining / rate);
+	const endTime = new Date(now.getTime() + eta * 1000);
+	return {
+		eta,
+		elapsed,
+		endTime,
+		rate,
+	};
 }
 
-//# sourceMappingURL=getEstimateProcessTime.js.map
+//# sourceMappingURL=getEstimateProcessTime.js.map

package/lib/utils/index.js

@@ -1,4 +1,4 @@
-export { getEstimateProcessTime } from "./getEstimateProcessTime.js";
-export { buildRedactorFormSchema } from "./buildRedactorFormSchema.js";
-export { buildBaseUrl } from "./buildBaseUrl.js";
+export { buildBaseUrl } from './buildBaseUrl.js';
+export { buildRedactorFormSchema } from './buildRedactorFormSchema.js';
+export { getEstimateProcessTime } from './getEstimateProcessTime.js';
 //# sourceMappingURL=index.js.map