@wener/common 2.0.5 → 2.0.6

package/lib/fs/minio/index.js

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

package/lib/fs/orpc/FileSystemContract.js

@@ -1,93 +1,93 @@
-import { oc } from "@orpc/contract";
-import { z } from "zod/v4";
-import { FileKindSchema } from "../types.js";
+import { oc } from '@orpc/contract';
+import { z } from 'zod/v4';
+import { FileKindSchema } from '../types.js';
 export const FileStatSchema = z.object({
-    directory: z.string(),
-    path: z.string(),
-    name: z.string(),
-    kind: FileKindSchema,
-    mtime: z.coerce.date(),
-    size: z.coerce.number().nonnegative().default(0),
-    meta: z.record(z.string(), z.any())
+	directory: z.string(),
+	path: z.string(),
+	name: z.string(),
+	kind: FileKindSchema,
+	mtime: z.coerce.date(),
+	size: z.coerce.number().nonnegative().default(0),
+	meta: z.record(z.string(), z.any()),
 });
 export const ReaddirInputSchema = z.object({
-    dir: z.string().nonempty(),
-    glob: z.string().optional(),
-    recursive: z.boolean().default(false),
-    depth: z.number().min(0).optional(),
-    kind: FileKindSchema.optional(),
-    cursor: z.string().optional(),
-    hidden: z.boolean().default(false)
+	dir: z.string().nonempty(),
+	glob: z.string().optional(),
+	recursive: z.boolean().default(false),
+	depth: z.number().min(0).optional(),
+	kind: FileKindSchema.optional(),
+	cursor: z.string().optional(),
+	hidden: z.boolean().default(false),
 });
 const ReaddirOutputSchema = z.object({
-    data: FileStatSchema.array()
+	data: FileStatSchema.array(),
 });
 const StatInputSchema = z.object({
-    path: z.string()
+	path: z.string(),
 });
 const StatOutputSchema = z.object({
-    data: FileStatSchema
+	data: FileStatSchema,
 });
 const CreateDirectoryInputSchema = z.object({
-    path: z.string(),
-    recursive: z.boolean().nullish()
+	path: z.string(),
+	recursive: z.boolean().nullish(),
 });
 const CreateDirectoryOutputSchema = z.object({}).default({});
 const RenameInputSchema = z.object({
-    oldPath: z.string(),
-    newPath: z.string(),
-    overwrite: z.boolean().nullish()
+	oldPath: z.string(),
+	newPath: z.string(),
+	overwrite: z.boolean().nullish(),
 });
 const RenameOutputSchema = z.object({}).default({});
 const ExistsInputSchema = z.object({
-    path: z.string()
+	path: z.string(),
 });
 const ExistsOutputSchema = z.object({
-    data: z.boolean()
+	data: z.boolean(),
 });
 const CopyInputSchema = z.object({
-    src: z.string(),
-    dest: z.string(),
-    overwrite: z.boolean().nullish(),
-    shallow: z.boolean().nullish()
+	src: z.string(),
+	dest: z.string(),
+	overwrite: z.boolean().nullish(),
+	shallow: z.boolean().nullish(),
 });
 const CopyOutputSchema = z.object({}).default({});
 const ReadFileInputSchema = z.object({
-    path: z.string()
+	path: z.string(),
 });
 const ReadFileOutputSchema = z.object({
-    base64: z.string()
+	base64: z.string(),
 });
 const WriteFileInputSchema = z.object({
-    path: z.string(),
-    base64: z.string(),
-    overwrite: z.boolean().optional()
+	path: z.string(),
+	base64: z.string(),
+	overwrite: z.boolean().optional(),
 });
 const WriteFileOutputSchema = z.object({});
 const RemoveInputSchema = z.object({
-    path: z.string(),
-    recursive: z.boolean().nullish(),
-    force: z.boolean().nullish()
+	path: z.string(),
+	recursive: z.boolean().nullish(),
+	force: z.boolean().nullish(),
 });
 const RemoveOutputSchema = z.object({}).default({});
 export const FileSystemContract = {
-    readdir: oc.input(ReaddirInputSchema).output(ReaddirOutputSchema).route({
-        description: "List directory contents"
-    }),
-    stat: oc.input(StatInputSchema).output(StatOutputSchema).route({
-        method: "GET",
-        description: "Get file or directory status"
-    }),
-    mkdir: oc.input(CreateDirectoryInputSchema).output(CreateDirectoryOutputSchema).route({
-        description: "Create a directory"
-    }),
-    readFile: oc.input(ReadFileInputSchema).output(ReadFileOutputSchema).route({
-        description: "Read file"
-    }),
-    writeFile: oc.input(WriteFileInputSchema).output(WriteFileOutputSchema),
-    rename: oc.input(RenameInputSchema).output(RenameOutputSchema),
-    exists: oc.input(ExistsInputSchema).output(ExistsOutputSchema),
-    copy: oc.input(CopyInputSchema).output(CopyOutputSchema),
-    rm: oc.input(RemoveInputSchema).output(RemoveOutputSchema)
+	readdir: oc.input(ReaddirInputSchema).output(ReaddirOutputSchema).route({
+		description: 'List directory contents',
+	}),
+	stat: oc.input(StatInputSchema).output(StatOutputSchema).route({
+		method: 'GET',
+		description: 'Get file or directory status',
+	}),
+	mkdir: oc.input(CreateDirectoryInputSchema).output(CreateDirectoryOutputSchema).route({
+		description: 'Create a directory',
+	}),
+	readFile: oc.input(ReadFileInputSchema).output(ReadFileOutputSchema).route({
+		description: 'Read file',
+	}),
+	writeFile: oc.input(WriteFileInputSchema).output(WriteFileOutputSchema),
+	rename: oc.input(RenameInputSchema).output(RenameOutputSchema),
+	exists: oc.input(ExistsInputSchema).output(ExistsOutputSchema),
+	copy: oc.input(CopyInputSchema).output(CopyOutputSchema),
+	rm: oc.input(RemoveInputSchema).output(RemoveOutputSchema),
 };
 //# sourceMappingURL=FileSystemContract.js.map

package/lib/fs/orpc/createContractClientFileSystem.js

@@ -1,93 +1,93 @@
-import { ArrayBuffers } from "@wener/utils";
-import { resolveData } from "../utils";
+import { ArrayBuffers } from '@wener/utils';
+import { resolveData } from '../utils';
 export function createContractClientFileSystem(client) {
-    return new ContractFS(client);
+	return new ContractFS(client);
 }
 let ContractFS = class ContractFS {
-    client;
-    constructor(client){
-        this.client = client;
-    }
-    async readdir(dir, options = {}) {
-        const { data } = await this.client.readdir({
-            dir,
-            ...options
-        });
-        return data.map((stat)=>({
-                ...stat,
-                mtime: stat.mtime.getTime()
-            }));
-    }
-    async stat(entry, _options) {
-        const { data } = await this.client.stat({
-            path: entry
-        });
-        return {
-            ...data,
-            mtime: data.mtime.getTime()
-        };
-    }
-    async mkdir(path, options) {
-        await this.client.mkdir({
-            path,
-            recursive: options?.recursive
-        });
-    }
-    async readFile(path, options) {
-        // Note: The contract doesn't currently support encoding options.
-        const { base64 } = await this.client.readFile({
-            path
-        });
-        let enc = options?.encoding || 'binary';
-        let buf = ArrayBuffers.fromBase64(base64);
-        switch(enc){
-            case 'text':
-                return ArrayBuffers.toString(buf);
-        }
-        return buf;
-    }
-    async writeFile(path, data, options) {
-        let buf = resolveData(data);
-        await this.client.writeFile({
-            path,
-            base64: ArrayBuffers.toBase64(buf),
-            ...options
-        });
-    }
-    async rename(oldPath, newPath, options) {
-        await this.client.rename({
-            oldPath,
-            newPath,
-            overwrite: options?.overwrite
-        });
-    }
-    async exists(path) {
-        const { data } = await this.client.exists({
-            path
-        });
-        return data;
-    }
-    async copy(src, dest, options) {
-        await this.client.copy({
-            src,
-            dest,
-            overwrite: options?.overwrite,
-            shallow: options?.shallow
-        });
-    }
-    async rm(path, options) {
-        await this.client.rm({
-            path,
-            recursive: options?.recursive,
-            force: options?.force
-        });
-    }
-    createReadStream(_path, _options) {
-        throw new Error('createReadStream is not implemented in ContractFS');
-    }
-    createWriteStream(_path, _options) {
-        throw new Error('createWriteStream is not implemented in ContractFS');
-    }
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async readdir(dir, options = {}) {
+		const { data } = await this.client.readdir({
+			dir,
+			...options,
+		});
+		return data.map((stat) => ({
+			...stat,
+			mtime: stat.mtime.getTime(),
+		}));
+	}
+	async stat(entry, _options) {
+		const { data } = await this.client.stat({
+			path: entry,
+		});
+		return {
+			...data,
+			mtime: data.mtime.getTime(),
+		};
+	}
+	async mkdir(path, options) {
+		await this.client.mkdir({
+			path,
+			recursive: options?.recursive,
+		});
+	}
+	async readFile(path, options) {
+		// Note: The contract doesn't currently support encoding options.
+		const { base64 } = await this.client.readFile({
+			path,
+		});
+		let enc = options?.encoding || 'binary';
+		let buf = ArrayBuffers.fromBase64(base64);
+		switch (enc) {
+			case 'text':
+				return ArrayBuffers.toString(buf);
+		}
+		return buf;
+	}
+	async writeFile(path, data, options) {
+		let buf = resolveData(data);
+		await this.client.writeFile({
+			path,
+			base64: ArrayBuffers.toBase64(buf),
+			...options,
+		});
+	}
+	async rename(oldPath, newPath, options) {
+		await this.client.rename({
+			oldPath,
+			newPath,
+			overwrite: options?.overwrite,
+		});
+	}
+	async exists(path) {
+		const { data } = await this.client.exists({
+			path,
+		});
+		return data;
+	}
+	async copy(src, dest, options) {
+		await this.client.copy({
+			src,
+			dest,
+			overwrite: options?.overwrite,
+			shallow: options?.shallow,
+		});
+	}
+	async rm(path, options) {
+		await this.client.rm({
+			path,
+			recursive: options?.recursive,
+			force: options?.force,
+		});
+	}
+	createReadStream(_path, _options) {
+		throw new Error('createReadStream is not implemented in ContractFS');
+	}
+	createWriteStream(_path, _options) {
+		throw new Error('createWriteStream is not implemented in ContractFS');
+	}
 };
 
-//# sourceMappingURL=createContractClientFileSystem.js.map
+//# sourceMappingURL=createContractClientFileSystem.js.map

package/lib/fs/orpc/index.js

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

package/lib/fs/orpc/server/createFileSystemContractImpl.js

@@ -1,63 +1,65 @@
-import { implement } from "@orpc/server";
-import { ArrayBuffers } from "@wener/utils";
-import { FileSystemContract } from "../FileSystemContract.js";
+import { implement } from '@orpc/server';
+import { ArrayBuffers } from '@wener/utils';
+import { FileSystemContract } from '../FileSystemContract.js';
 export function createFileSystemContractImpl(ifs) {
-    const os = implement(FileSystemContract);
-    return {
-        readdir: os.readdir.handler(async ({ input }) => {
-            return {
-                data: await ifs.readdir(input.dir)
-            };
-        }),
-        stat: os.stat.handler(async ({ input }) => {
-            return {
-                data: await ifs.stat(input.path)
-            };
-        }),
-        mkdir: os.mkdir.handler(async ({ input }) => {
-            await ifs.mkdir(input.path, {
-                recursive: input.recursive ?? false
-            });
-            return {};
-        }),
-        rename: os.rename.handler(async ({ input }) => {
-            await ifs.rename(input.oldPath, input.newPath, {
-                overwrite: input.overwrite ?? false
-            });
-            return {};
-        }),
-        exists: os.exists.handler(async ({ input }) => {
-            return {
-                data: await ifs.exists(input.path)
-            };
-        }),
-        copy: os.copy.handler(async ({ input }) => {
-            await ifs.copy(input.src, input.dest, {
-                overwrite: input.overwrite ?? false,
-                shallow: input.shallow ?? false
-            });
-            return {};
-        }),
-        readFile: os.readFile.handler(async ({ input }) => {
-            return {
-                base64: ArrayBuffers.toBase64(await ifs.readFile(input.path, {
-                    encoding: "binary"
-                }))
-            };
-        }),
-        writeFile: os.writeFile.handler(async ({ input }) => {
-            await ifs.writeFile(input.path, Buffer.from(input.base64, "base64"), {
-                overwrite: input.overwrite
-            });
-            return {};
-        }),
-        rm: os.rm.handler(async ({ input }) => {
-            await ifs.rm(input.path, {
-                recursive: input.recursive ?? undefined,
-                force: input.force ?? undefined
-            });
-            return {};
-        })
-    };
+	const os = implement(FileSystemContract);
+	return {
+		readdir: os.readdir.handler(async ({ input }) => {
+			return {
+				data: await ifs.readdir(input.dir),
+			};
+		}),
+		stat: os.stat.handler(async ({ input }) => {
+			return {
+				data: await ifs.stat(input.path),
+			};
+		}),
+		mkdir: os.mkdir.handler(async ({ input }) => {
+			await ifs.mkdir(input.path, {
+				recursive: input.recursive ?? false,
+			});
+			return {};
+		}),
+		rename: os.rename.handler(async ({ input }) => {
+			await ifs.rename(input.oldPath, input.newPath, {
+				overwrite: input.overwrite ?? false,
+			});
+			return {};
+		}),
+		exists: os.exists.handler(async ({ input }) => {
+			return {
+				data: await ifs.exists(input.path),
+			};
+		}),
+		copy: os.copy.handler(async ({ input }) => {
+			await ifs.copy(input.src, input.dest, {
+				overwrite: input.overwrite ?? false,
+				shallow: input.shallow ?? false,
+			});
+			return {};
+		}),
+		readFile: os.readFile.handler(async ({ input }) => {
+			return {
+				base64: ArrayBuffers.toBase64(
+					await ifs.readFile(input.path, {
+						encoding: 'binary',
+					}),
+				),
+			};
+		}),
+		writeFile: os.writeFile.handler(async ({ input }) => {
+			await ifs.writeFile(input.path, Buffer.from(input.base64, 'base64'), {
+				overwrite: input.overwrite,
+			});
+			return {};
+		}),
+		rm: os.rm.handler(async ({ input }) => {
+			await ifs.rm(input.path, {
+				recursive: input.recursive ?? undefined,
+				force: input.force ?? undefined,
+			});
+			return {};
+		}),
+	};
 }
 //# sourceMappingURL=createFileSystemContractImpl.js.map

package/lib/fs/orpc/server/index.js

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