@wener/common 2.0.5 → 2.0.6

package/lib/fs/types.js

@@ -1,27 +1,24 @@
-import { z } from "zod/v4";
+import { z } from 'zod/v4';
 export const FileKind = Object.freeze({
-    __proto__: null,
-    directory: 'directory',
-    file: 'file'
+	__proto__: null,
+	directory: 'directory',
+	file: 'file',
 });
-export const FileKindSchema = z.enum([
-    'directory',
-    'file'
-]);
+export const FileKindSchema = z.enum(['directory', 'file']);
 export const ReaddirOptionsSchema = z.object({
-    recursive: z.boolean().optional(),
-    depth: z.number().optional(),
-    glob: z.string().optional(),
-    kind: FileKindSchema.optional(),
-    cursor: z.string().optional(),
-    hidden: z.boolean().default(false)
+	recursive: z.boolean().optional(),
+	depth: z.number().optional(),
+	glob: z.string().optional(),
+	kind: FileKindSchema.optional(),
+	cursor: z.string().optional(),
+	hidden: z.boolean().default(false),
 });
 export const FileUrlOptionsSchema = z.object({
-    size: z.coerce.number().optional(),
-    width: z.number().optional(),
-    height: z.number().optional(),
-    quality: z.number().optional(),
-    thumbnail: z.boolean().optional()
+	size: z.coerce.number().optional(),
+	width: z.number().optional(),
+	height: z.number().optional(),
+	quality: z.number().optional(),
+	thumbnail: z.boolean().optional(),
 });
 
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/lib/fs/utils/getFileUrl.js

@@ -1,35 +1,29 @@
 export function getFileUrl(fs, needle, { ...options } = {}) {
-    const [file, path] = resolveFilePath(needle);
-    if (!path || !needle) return;
-    let out;
-    if (fs?.getUrl) {
-        try {
-            out = fs.getUrl(needle, options);
-        } catch (e) {
-            console.error(`failed to get file url`, needle, e);
-        }
-    }
-    if (!out && file) {
-        out = file.meta?.url || file.url;
-    }
-    return out;
+	const [file, path] = resolveFilePath(needle);
+	if (!path || !needle) return;
+	let out;
+	if (fs?.getUrl) {
+		try {
+			out = fs.getUrl(needle, options);
+		} catch (e) {
+			console.error(`failed to get file url`, needle, e);
+		}
+	}
+	if (!out && file) {
+		out = file.meta?.url || file.url;
+	}
+	return out;
 }
 export function resolveFilePath(needle) {
-    if (!needle) {
-        return [
-            undefined,
-            undefined
-        ];
-    }
-    let file = typeof needle === 'string' ? undefined : needle;
-    let path = typeof needle === 'string' ? needle : needle.path;
-    if (file && !path) {
-        path = file.path;
-    }
-    return [
-        file,
-        path
-    ];
+	if (!needle) {
+		return [undefined, undefined];
+	}
+	let file = typeof needle === 'string' ? undefined : needle;
+	let path = typeof needle === 'string' ? needle : needle.path;
+	if (file && !path) {
+		path = file.path;
+	}
+	return [file, path];
 }
 
-//# sourceMappingURL=getFileUrl.js.map
+//# sourceMappingURL=getFileUrl.js.map

package/lib/fs/utils.js

@@ -1,22 +1,22 @@
-import { ArrayBuffers, classOf } from "@wener/utils";
+import { ArrayBuffers, classOf } from '@wener/utils';
 export function resolveData(data) {
-    let buf;
-    if (typeof data === 'string') {
-        buf = ArrayBuffers.toUint8Array(ArrayBuffers.from(data, 'utf8'));
-    } else if (data instanceof ArrayBuffer) {
-        buf = new Uint8Array(data);
-    } else if (data instanceof Uint8Array) {
-        buf = data;
-    } else {
-        throw new Error(`unable to resolve data: ${typeof data} ${classOf(data)}`);
-    }
-    return buf;
+	let buf;
+	if (typeof data === 'string') {
+		buf = ArrayBuffers.toUint8Array(ArrayBuffers.from(data, 'utf8'));
+	} else if (data instanceof ArrayBuffer) {
+		buf = new Uint8Array(data);
+	} else if (data instanceof Uint8Array) {
+		buf = data;
+	} else {
+		throw new Error(`unable to resolve data: ${typeof data} ${classOf(data)}`);
+	}
+	return buf;
 }
 export function getPath(f) {
-    if (typeof f === 'string') {
-        return f;
-    }
-    return f.path;
+	if (typeof f === 'string') {
+		return f;
+	}
+	return f.path;
 }
 
-//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=utils.js.map

package/lib/fs/webdav/index.js

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

package/lib/index.js

@@ -1,7 +1,7 @@
 /**
  * @deprecated
- */ export { parseSort } from "./data/parseSort.js";
+ */ export { parseSort } from './data/parseSort.js';
 /**
  * @deprecated
- */ export { resolvePagination as normalizePagination } from "./data/resolvePagination.js";
+ */ export { resolvePagination as normalizePagination } from './data/resolvePagination.js';
 //# sourceMappingURL=index.js.map

package/lib/jsonschema/JsonSchema.js

@@ -1,180 +1,241 @@
-import { isNil } from "@wener/utils";
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
-import addKeywords from "ajv-keywords";
-import { match, P } from "ts-pattern";
+import { isNil } from '@wener/utils';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import addKeywords from 'ajv-keywords';
+import { match, P } from 'ts-pattern';
+
 function _createValidator(opt) {
-    const ajv = new Ajv(opt);
-    addKeywords(ajv);
-    addFormats(ajv);
-    return ajv;
+	const ajv = new Ajv(opt);
+	addKeywords(ajv);
+	addFormats(ajv);
+	return ajv;
 }
 function validate({ schema, data, mutate, clone, validator }) {
-    let opts = {
-        // strict: 'log',
-        strict: true,
-        strictSchema: 'log'
-    };
-    if (mutate) {
-        Object.assign(opts, {
-            removeAdditional: true,
-            useDefaults: true,
-            coerceTypes: true,
-            allErrors: true
-        });
-    }
-    if (clone) {
-        data = structuredClone(data);
-    }
-    if (!validator) {
-        validator = JsonSchema.createValidator(opts);
-    }
-    const validate = validator.compile(schema);
-    // consider reusing validate instance
-    const valid = validate(data);
-    const errors = validate.errors;
-    // localize(errors);
-    return {
-        data,
-        success: valid,
-        message: validator.errorsText(errors),
-        errors: errors
-    };
+	let opts = {
+		// strict: 'log',
+		strict: true,
+		strictSchema: 'log',
+	};
+	if (mutate) {
+		Object.assign(opts, {
+			removeAdditional: true,
+			useDefaults: true,
+			coerceTypes: true,
+			allErrors: true,
+		});
+	}
+	if (clone) {
+		data = structuredClone(data);
+	}
+	if (!validator) {
+		validator = JsonSchema.createValidator(opts);
+	}
+	const validate = validator.compile(schema);
+	// consider reusing validate instance
+	const valid = validate(data);
+	const errors = validate.errors;
+	// localize(errors);
+	return {
+		data,
+		success: valid,
+		message: validator.errorsText(errors),
+		errors: errors,
+	};
 }
 let schemas = [];
 let createValidator = _createValidator;
 function addSchema(schema, { onConflict = 'throw' } = {}) {
-    if (!schema.$id) throw new Error('Schema must have $id');
-    switch(onConflict){
-        case 'ignore':
-            onConflict = (old)=>old;
-            break;
-        case 'replace':
-            onConflict = (_, neo)=>neo;
-            break;
-        case 'throw':
-            onConflict = (_old, neo)=>{
-                throw new Error(`Schema ${neo.$id} already exists`);
-            };
-            break;
-    }
-    let idx = schemas.findIndex((s)=>s.$id === schema.$id);
-    if (idx >= 0) {
-        schemas[idx] = onConflict(schemas[idx], schema);
-    } else {
-        schemas.push(schema);
-    }
+	if (!schema.$id) throw new Error('Schema must have $id');
+	switch (onConflict) {
+		case 'ignore':
+			onConflict = (old) => old;
+			break;
+		case 'replace':
+			onConflict = (_, neo) => neo;
+			break;
+		case 'throw':
+			onConflict = (_old, neo) => {
+				throw new Error(`Schema ${neo.$id} already exists`);
+			};
+			break;
+	}
+	let idx = schemas.findIndex((s) => s.$id === schema.$id);
+	if (idx >= 0) {
+		schemas[idx] = onConflict(schemas[idx], schema);
+	} else {
+		schemas.push(schema);
+	}
 }
 /**
  * Check data is valid, will not use default
  */ function check(schema, data) {
-    return validate({
-        schema,
-        data,
-        mutate: false,
-        clone: true
-    });
+	return validate({
+		schema,
+		data,
+		mutate: false,
+		clone: true,
+	});
 }
 /**
  * Parse data with default value and coerceTypes
  */ function safeParse(schema, data) {
-    return validate({
-        schema,
-        data,
-        mutate: true,
-        clone: true
-    });
+	return validate({
+		schema,
+		data,
+		mutate: true,
+		clone: true,
+	});
 }
 function parse(schema, data) {
-    const { data: out, message, errors } = validate({
-        schema,
-        data,
-        mutate: true,
-        clone: true
-    });
-    if (errors) {
-        throw new Error(message);
-    }
-    return out;
+	const {
+		data: out,
+		message,
+		errors,
+	} = validate({
+		schema,
+		data,
+		mutate: true,
+		clone: true,
+	});
+	if (errors) {
+		throw new Error(message);
+	}
+	return out;
 }
 function create(schema, data) {
-    // will not ensure value match the rule
-    return match(schema).returnType().with({
-        const: P.nonNullable
-    }, (v)=>v).with({
-        default: P.select()
-    }, (v)=>v).with({
-        anyOf: P.nonNullable
-    }, (schema)=>{
-        return create(schema.anyOf[0]);
-    }).with({
-        oneOf: P.nonNullable
-    }, (schema)=>{
-        return create(schema.oneOf[0]);
-    }).with({
-        type: 'string'
-    }, (_schema)=>'').with({
-        type: P.union('number', 'integer')
-    }, (_schema)=>0).with({
-        type: 'object'
-    }, (schema)=>{
-        let out = validate({
-            schema,
-            data: data ?? {},
-            mutate: true
-        });
-        if (!out.success) {
-            // fallback
-            let obj = data || {};
-            schema.required?.forEach((key)=>{
-                if (!(key in obj)) {
-                    let last = obj[key];
-                    let prop = schema.properties?.[key];
-                    if (prop && isNil(last)) obj[key] = JsonSchema.create(prop, last);
-                }
-            });
-            out = validate({
-                schema,
-                data: obj,
-                mutate: true
-            });
-            if (!out.success) {
-                console.warn(`Failed to create object with schema: ${out.message}`);
-            }
-        }
-        return out.data;
-    }).with({
-        type: 'null'
-    }, ()=>null).with({
-        type: 'boolean'
-    }, (_schema)=>false).with({
-        type: 'array'
-    }, (_schema)=>[]).otherwise(()=>{
-        return undefined;
-    });
+	// will not ensure value match the rule
+	return match(schema)
+		.returnType()
+		.with(
+			{
+				const: P.nonNullable,
+			},
+			(v) => v,
+		)
+		.with(
+			{
+				default: P.select(),
+			},
+			(v) => v,
+		)
+		.with(
+			{
+				anyOf: P.nonNullable,
+			},
+			(schema) => {
+				return create(schema.anyOf[0]);
+			},
+		)
+		.with(
+			{
+				oneOf: P.nonNullable,
+			},
+			(schema) => {
+				return create(schema.oneOf[0]);
+			},
+		)
+		.with(
+			{
+				type: 'string',
+			},
+			(_schema) => '',
+		)
+		.with(
+			{
+				type: P.union('number', 'integer'),
+			},
+			(_schema) => 0,
+		)
+		.with(
+			{
+				type: 'object',
+			},
+			(schema) => {
+				let out = validate({
+					schema,
+					data: data ?? {},
+					mutate: true,
+				});
+				if (!out.success) {
+					// fallback
+					let obj = data || {};
+					schema.required?.forEach((key) => {
+						if (!(key in obj)) {
+							let last = obj[key];
+							let prop = schema.properties?.[key];
+							if (prop && isNil(last)) obj[key] = JsonSchema.create(prop, last);
+						}
+					});
+					out = validate({
+						schema,
+						data: obj,
+						mutate: true,
+					});
+					if (!out.success) {
+						console.warn(`Failed to create object with schema: ${out.message}`);
+					}
+				}
+				return out.data;
+			},
+		)
+		.with(
+			{
+				type: 'null',
+			},
+			() => null,
+		)
+		.with(
+			{
+				type: 'boolean',
+			},
+			(_schema) => false,
+		)
+		.with(
+			{
+				type: 'array',
+			},
+			(_schema) => [],
+		)
+		.otherwise(() => {
+			return undefined;
+		});
 }
 function isPrimitiveType(schema) {
-    return match(schema).returnType().with({
-        type: P.union('number', 'integer', 'string', 'boolean')
-    }, ()=>true).with({
-        anyOf: P.nonNullable
-    }, (schema)=>{
-        return isPrimitiveType(schema.anyOf[0]);
-    }).with({
-        oneOf: P.nonNullable
-    }, (schema)=>{
-        return isPrimitiveType(schema.oneOf[0]);
-    }).otherwise(()=>false);
+	return match(schema)
+		.returnType()
+		.with(
+			{
+				type: P.union('number', 'integer', 'string', 'boolean'),
+			},
+			() => true,
+		)
+		.with(
+			{
+				anyOf: P.nonNullable,
+			},
+			(schema) => {
+				return isPrimitiveType(schema.anyOf[0]);
+			},
+		)
+		.with(
+			{
+				oneOf: P.nonNullable,
+			},
+			(schema) => {
+				return isPrimitiveType(schema.oneOf[0]);
+			},
+		)
+		.otherwise(() => false);
 }
 export const JsonSchema = {
-    createValidator,
-    addSchema,
-    schemas,
-    check,
-    safeParse,
-    parse,
-    create,
-    isPrimitiveType
+	createValidator,
+	addSchema,
+	schemas,
+	check,
+	safeParse,
+	parse,
+	create,
+	isPrimitiveType,
 };
 
-//# sourceMappingURL=JsonSchema.js.map
+//# sourceMappingURL=JsonSchema.js.map