@frictionless-ts/dataset 1.0.1

package/README.md

@@ -0,0 +1,3 @@
+# @frictionless-ts/dataset
+
+frictionless-ts is a fast TypeScript data management framework built on top of the Data Package standard and Polars DataFrames. It supports various formats like CSV, JSON, and Parquet and integrates with data platforms such as CKAN, Zenodo, and GitHub. For more information, please read the [project's documentation](https://frictionlessdata.github.io/frictionless-ts/).

package/build/file/copy.d.ts

@@ -0,0 +1,4 @@
+export declare function copyFile(options: {
+    sourcePath: string;
+    targetPath: string;
+}): Promise<void>;

package/build/file/copy.js

@@ -0,0 +1,7 @@
+import { loadFileStream } from "../stream/load.js";
+import { saveFileStream } from "../stream/save.js";
+export async function copyFile(options) {
+    const stream = await loadFileStream(options.sourcePath);
+    await saveFileStream(stream, { path: options.targetPath });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29weS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2ZpbGUvY29weS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUE7QUFDbEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBRWxELE1BQU0sQ0FBQyxLQUFLLFVBQVUsUUFBUSxDQUFDLE9BRzlCO0lBQ0MsTUFBTSxNQUFNLEdBQUcsTUFBTSxjQUFjLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUFBO0lBQ3ZELE1BQU0sY0FBYyxDQUFDLE1BQU0sRUFBRSxFQUFFLElBQUksRUFBRSxPQUFPLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQTtBQUM1RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbG9hZEZpbGVTdHJlYW0gfSBmcm9tIFwiLi4vc3RyZWFtL2xvYWQudHNcIlxuaW1wb3J0IHsgc2F2ZUZpbGVTdHJlYW0gfSBmcm9tIFwiLi4vc3RyZWFtL3NhdmUudHNcIlxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gY29weUZpbGUob3B0aW9uczoge1xuICBzb3VyY2VQYXRoOiBzdHJpbmdcbiAgdGFyZ2V0UGF0aDogc3RyaW5nXG59KSB7XG4gIGNvbnN0IHN0cmVhbSA9IGF3YWl0IGxvYWRGaWxlU3RyZWFtKG9wdGlvbnMuc291cmNlUGF0aClcbiAgYXdhaXQgc2F2ZUZpbGVTdHJlYW0oc3RyZWFtLCB7IHBhdGg6IG9wdGlvbnMudGFyZ2V0UGF0aCB9KVxufVxuIl19

package/build/file/copy.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/file/copy.spec.js

@@ -0,0 +1,104 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { temporaryDirectory } from "tempy";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { copyFile } from "./copy.js";
+import { writeTempFile } from "./temp.js";
+describe("copyFile", () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = temporaryDirectory();
+    });
+    afterEach(async () => {
+        try {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            if (error instanceof Error && !error.message.includes("ENOENT")) {
+                console.error(`Failed to clean up test directory: ${testDir}`, error);
+            }
+        }
+    });
+    it("should copy file from source to target", async () => {
+        const sourcePath = await writeTempFile("test content");
+        const targetPath = path.join(testDir, "target.txt");
+        await copyFile({ sourcePath, targetPath });
+        const fileExists = await fs
+            .stat(targetPath)
+            .then(() => true)
+            .catch(() => false);
+        expect(fileExists).toBe(true);
+        const content = await fs.readFile(targetPath, "utf-8");
+        expect(content).toBe("test content");
+    });
+    it("should copy file with exact content", async () => {
+        const content = "Hello, World! This is a test file.";
+        const sourcePath = await writeTempFile(content);
+        const targetPath = path.join(testDir, "copy.txt");
+        await copyFile({ sourcePath, targetPath });
+        const copiedContent = await fs.readFile(targetPath, "utf-8");
+        expect(copiedContent).toBe(content);
+    });
+    it("should copy binary file", async () => {
+        const binaryData = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10]);
+        const sourcePath = await writeTempFile(binaryData);
+        const targetPath = path.join(testDir, "binary.bin");
+        await copyFile({ sourcePath, targetPath });
+        const copiedData = await fs.readFile(targetPath);
+        expect(Buffer.compare(copiedData, binaryData)).toBe(0);
+    });
+    it("should copy empty file", async () => {
+        const sourcePath = await writeTempFile("");
+        const targetPath = path.join(testDir, "empty.txt");
+        await copyFile({ sourcePath, targetPath });
+        const content = await fs.readFile(targetPath, "utf-8");
+        expect(content).toBe("");
+    });
+    it("should copy large file", async () => {
+        const largeContent = "x".repeat(100000);
+        const sourcePath = await writeTempFile(largeContent);
+        const targetPath = path.join(testDir, "large.txt");
+        await copyFile({ sourcePath, targetPath });
+        const copiedContent = await fs.readFile(targetPath, "utf-8");
+        expect(copiedContent).toBe(largeContent);
+        expect(copiedContent.length).toBe(100000);
+    });
+    it("should copy file with special characters", async () => {
+        const content = "Special characters: é, ñ, ü, ö, à, 中文, 日本語";
+        const sourcePath = await writeTempFile(content);
+        const targetPath = path.join(testDir, "special.txt");
+        await copyFile({ sourcePath, targetPath });
+        const copiedContent = await fs.readFile(targetPath, "utf-8");
+        expect(copiedContent).toBe(content);
+    });
+    it("should copy file to nested directory", async () => {
+        const sourcePath = await writeTempFile("nested content");
+        const targetPath = path.join(testDir, "nested", "dir", "file.txt");
+        await copyFile({ sourcePath, targetPath });
+        const fileExists = await fs
+            .stat(targetPath)
+            .then(() => true)
+            .catch(() => false);
+        expect(fileExists).toBe(true);
+        const content = await fs.readFile(targetPath, "utf-8");
+        expect(content).toBe("nested content");
+    });
+    it("should copy json file", async () => {
+        const jsonContent = JSON.stringify({ name: "test", value: 123 });
+        const sourcePath = await writeTempFile(jsonContent);
+        const targetPath = path.join(testDir, "data.json");
+        await copyFile({ sourcePath, targetPath });
+        const copiedContent = await fs.readFile(targetPath, "utf-8");
+        expect(copiedContent).toBe(jsonContent);
+        expect(JSON.parse(copiedContent)).toEqual({ name: "test", value: 123 });
+    });
+    it("should copy file with newlines", async () => {
+        const content = "Line 1\nLine 2\nLine 3\n";
+        const sourcePath = await writeTempFile(content);
+        const targetPath = path.join(testDir, "multiline.txt");
+        await copyFile({ sourcePath, targetPath });
+        const copiedContent = await fs.readFile(targetPath, "utf-8");
+        expect(copiedContent).toBe(content);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copy.spec.js","sourceRoot":"","sources":["../../file/copy.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from \"node:fs/promises\"\nimport * as path from \"node:path\"\nimport { temporaryDirectory } from \"tempy\"\nimport { afterEach, beforeEach, describe, expect, it } from \"vitest\"\nimport { copyFile } from \"./copy.ts\"\nimport { writeTempFile } from \"./temp.ts\"\n\ndescribe(\"copyFile\", () => {\n  let testDir: string\n\n  beforeEach(() => {\n    testDir = temporaryDirectory()\n  })\n\n  afterEach(async () => {\n    try {\n      await fs.rm(testDir, { recursive: true, force: true })\n    } catch (error) {\n      if (error instanceof Error && !error.message.includes(\"ENOENT\")) {\n        console.error(`Failed to clean up test directory: ${testDir}`, error)\n      }\n    }\n  })\n\n  it(\"should copy file from source to target\", async () => {\n    const sourcePath = await writeTempFile(\"test content\")\n    const targetPath = path.join(testDir, \"target.txt\")\n\n    await copyFile({ sourcePath, targetPath })\n\n    const fileExists = await fs\n      .stat(targetPath)\n      .then(() => true)\n      .catch(() => false)\n    expect(fileExists).toBe(true)\n\n    const content = await fs.readFile(targetPath, \"utf-8\")\n    expect(content).toBe(\"test content\")\n  })\n\n  it(\"should copy file with exact content\", async () => {\n    const content = \"Hello, World! This is a test file.\"\n    const sourcePath = await writeTempFile(content)\n    const targetPath = path.join(testDir, \"copy.txt\")\n\n    await copyFile({ sourcePath, targetPath })\n\n    const copiedContent = await fs.readFile(targetPath, \"utf-8\")\n    expect(copiedContent).toBe(content)\n  })\n\n  it(\"should copy binary file\", async () => {\n    const binaryData = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10])\n    const sourcePath = await writeTempFile(binaryData)\n    const targetPath = path.join(testDir, \"binary.bin\")\n\n    await copyFile({ sourcePath, targetPath })\n\n    const copiedData = await fs.readFile(targetPath)\n    expect(Buffer.compare(copiedData, binaryData)).toBe(0)\n  })\n\n  it(\"should copy empty file\", async () => {\n    const sourcePath = await writeTempFile(\"\")\n    const targetPath = path.join(testDir, \"empty.txt\")\n\n    await copyFile({ sourcePath, targetPath })\n\n    const content = await fs.readFile(targetPath, \"utf-8\")\n    expect(content).toBe(\"\")\n  })\n\n  it(\"should copy large file\", async () => {\n    const largeContent = \"x\".repeat(100000)\n    const sourcePath = await writeTempFile(largeContent)\n    const targetPath = path.join(testDir, \"large.txt\")\n\n    await copyFile({ sourcePath, targetPath })\n\n    const copiedContent = await fs.readFile(targetPath, \"utf-8\")\n    expect(copiedContent).toBe(largeContent)\n    expect(copiedContent.length).toBe(100000)\n  })\n\n  it(\"should copy file with special characters\", async () => {\n    const content = \"Special characters: é, ñ, ü, ö, à, 中文, 日本語\"\n    const sourcePath = await writeTempFile(content)\n    const targetPath = path.join(testDir, \"special.txt\")\n\n    await copyFile({ sourcePath, targetPath })\n\n    const copiedContent = await fs.readFile(targetPath, \"utf-8\")\n    expect(copiedContent).toBe(content)\n  })\n\n  it(\"should copy file to nested directory\", async () => {\n    const sourcePath = await writeTempFile(\"nested content\")\n    const targetPath = path.join(testDir, \"nested\", \"dir\", \"file.txt\")\n\n    await copyFile({ sourcePath, targetPath })\n\n    const fileExists = await fs\n      .stat(targetPath)\n      .then(() => true)\n      .catch(() => false)\n    expect(fileExists).toBe(true)\n\n    const content = await fs.readFile(targetPath, \"utf-8\")\n    expect(content).toBe(\"nested content\")\n  })\n\n  it(\"should copy json file\", async () => {\n    const jsonContent = JSON.stringify({ name: \"test\", value: 123 })\n    const sourcePath = await writeTempFile(jsonContent)\n    const targetPath = path.join(testDir, \"data.json\")\n\n    await copyFile({ sourcePath, targetPath })\n\n    const copiedContent = await fs.readFile(targetPath, \"utf-8\")\n    expect(copiedContent).toBe(jsonContent)\n    expect(JSON.parse(copiedContent)).toEqual({ name: \"test\", value: 123 })\n  })\n\n  it(\"should copy file with newlines\", async () => {\n    const content = \"Line 1\\nLine 2\\nLine 3\\n\"\n    const sourcePath = await writeTempFile(content)\n    const targetPath = path.join(testDir, \"multiline.txt\")\n\n    await copyFile({ sourcePath, targetPath })\n\n    const copiedContent = await fs.readFile(targetPath, \"utf-8\")\n    expect(copiedContent).toBe(content)\n  })\n})\n"]}

package/build/file/describe.d.ts

@@ -0,0 +1,7 @@
+import type { HashType } from "./infer.ts";
+export declare function describeFile(path: string, options?: {
+    hashType?: HashType;
+}): Promise<{
+    bytes: number;
+    hash: string;
+}>;

package/build/file/describe.js

@@ -0,0 +1,9 @@
+import { prefetchFile } from "./fetch.js";
+import { inferBytes, inferHash } from "./infer.js";
+export async function describeFile(path, options) {
+    const localPath = await prefetchFile(path);
+    const bytes = await inferBytes({ path: localPath });
+    const hash = await inferHash({ path: localPath }, { hashType: options?.hashType });
+    return { bytes, hash };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzY3JpYmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9maWxlL2Rlc2NyaWJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxZQUFZLENBQUE7QUFDekMsT0FBTyxFQUFFLFVBQVUsRUFBRSxTQUFTLEVBQUUsTUFBTSxZQUFZLENBQUE7QUFHbEQsTUFBTSxDQUFDLEtBQUssVUFBVSxZQUFZLENBQ2hDLElBQVksRUFDWixPQUFpQztJQUVqQyxNQUFNLFNBQVMsR0FBRyxNQUFNLFlBQVksQ0FBQyxJQUFJLENBQUMsQ0FBQTtJQUUxQyxNQUFNLEtBQUssR0FBRyxNQUFNLFVBQVUsQ0FBQyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsQ0FBQyxDQUFBO0lBQ25ELE1BQU0sSUFBSSxHQUFHLE1BQU0sU0FBUyxDQUMxQixFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsRUFDbkIsRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBRSxDQUNoQyxDQUFBO0lBRUQsT0FBTyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsQ0FBQTtBQUN4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcHJlZmV0Y2hGaWxlIH0gZnJvbSBcIi4vZmV0Y2gudHNcIlxuaW1wb3J0IHsgaW5mZXJCeXRlcywgaW5mZXJIYXNoIH0gZnJvbSBcIi4vaW5mZXIudHNcIlxuaW1wb3J0IHR5cGUgeyBIYXNoVHlwZSB9IGZyb20gXCIuL2luZmVyLnRzXCJcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGRlc2NyaWJlRmlsZShcbiAgcGF0aDogc3RyaW5nLFxuICBvcHRpb25zPzogeyBoYXNoVHlwZT86IEhhc2hUeXBlIH0sXG4pIHtcbiAgY29uc3QgbG9jYWxQYXRoID0gYXdhaXQgcHJlZmV0Y2hGaWxlKHBhdGgpXG5cbiAgY29uc3QgYnl0ZXMgPSBhd2FpdCBpbmZlckJ5dGVzKHsgcGF0aDogbG9jYWxQYXRoIH0pXG4gIGNvbnN0IGhhc2ggPSBhd2FpdCBpbmZlckhhc2goXG4gICAgeyBwYXRoOiBsb2NhbFBhdGggfSxcbiAgICB7IGhhc2hUeXBlOiBvcHRpb25zPy5oYXNoVHlwZSB9LFxuICApXG5cbiAgcmV0dXJuIHsgYnl0ZXMsIGhhc2ggfVxufVxuIl19

package/build/file/fetch.d.ts

@@ -0,0 +1,2 @@
+export declare function prefetchFiles(path?: string | string[]): Promise<string[]>;
+export declare function prefetchFile(path: string): Promise<string>;

package/build/file/fetch.js

@@ -0,0 +1,21 @@
+import os from "node:os";
+import { isRemotePath } from "@frictionless-ts/metadata";
+import pAll from "p-all";
+import { copyFile } from "./copy.js";
+import { getTempFilePath } from "./temp.js";
+export async function prefetchFiles(path) {
+    if (!path)
+        return [];
+    const paths = Array.isArray(path) ? path : [path];
+    const concurrency = os.cpus().length;
+    const newPaths = await pAll(paths.map(path => () => prefetchFile(path)), { concurrency });
+    return newPaths;
+}
+export async function prefetchFile(path) {
+    if (!isRemotePath(path))
+        return path;
+    const newPath = getTempFilePath();
+    await copyFile({ sourcePath: path, targetPath: newPath });
+    return newPath;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/file/index.d.ts

@@ -0,0 +1,9 @@
+export { loadFile } from "./load.ts";
+export { copyFile } from "./copy.ts";
+export { saveFile } from "./save.ts";
+export { getTempFilePath, writeTempFile } from "./temp.ts";
+export { assertLocalPathVacant, isLocalPathExist } from "./path.ts";
+export { prefetchFile, prefetchFiles } from "./fetch.ts";
+export { inferEncoding, inferBytes, inferHash } from "./infer.ts";
+export { describeFile } from "./describe.ts";
+export { validateFile } from "./validate.ts";

package/build/file/index.js

@@ -0,0 +1,10 @@
+export { loadFile } from "./load.js";
+export { copyFile } from "./copy.js";
+export { saveFile } from "./save.js";
+export { getTempFilePath, writeTempFile } from "./temp.js";
+export { assertLocalPathVacant, isLocalPathExist } from "./path.js";
+export { prefetchFile, prefetchFiles } from "./fetch.js";
+export { inferEncoding, inferBytes, inferHash } from "./infer.js";
+export { describeFile } from "./describe.js";
+export { validateFile } from "./validate.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9maWxlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDcEMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUNwQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ3BDLE9BQU8sRUFBRSxlQUFlLEVBQUUsYUFBYSxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQzFELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUNuRSxPQUFPLEVBQUUsWUFBWSxFQUFFLGFBQWEsRUFBRSxNQUFNLFlBQVksQ0FBQTtBQUN4RCxPQUFPLEVBQUUsYUFBYSxFQUFFLFVBQVUsRUFBRSxTQUFTLEVBQUUsTUFBTSxZQUFZLENBQUE7QUFDakUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUM1QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sZUFBZSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgbG9hZEZpbGUgfSBmcm9tIFwiLi9sb2FkLnRzXCJcbmV4cG9ydCB7IGNvcHlGaWxlIH0gZnJvbSBcIi4vY29weS50c1wiXG5leHBvcnQgeyBzYXZlRmlsZSB9IGZyb20gXCIuL3NhdmUudHNcIlxuZXhwb3J0IHsgZ2V0VGVtcEZpbGVQYXRoLCB3cml0ZVRlbXBGaWxlIH0gZnJvbSBcIi4vdGVtcC50c1wiXG5leHBvcnQgeyBhc3NlcnRMb2NhbFBhdGhWYWNhbnQsIGlzTG9jYWxQYXRoRXhpc3QgfSBmcm9tIFwiLi9wYXRoLnRzXCJcbmV4cG9ydCB7IHByZWZldGNoRmlsZSwgcHJlZmV0Y2hGaWxlcyB9IGZyb20gXCIuL2ZldGNoLnRzXCJcbmV4cG9ydCB7IGluZmVyRW5jb2RpbmcsIGluZmVyQnl0ZXMsIGluZmVySGFzaCB9IGZyb20gXCIuL2luZmVyLnRzXCJcbmV4cG9ydCB7IGRlc2NyaWJlRmlsZSB9IGZyb20gXCIuL2Rlc2NyaWJlLnRzXCJcbmV4cG9ydCB7IHZhbGlkYXRlRmlsZSB9IGZyb20gXCIuL3ZhbGlkYXRlLnRzXCJcbiJdfQ==

package/build/file/infer.d.ts

@@ -0,0 +1,10 @@
+import type { Resource } from "@frictionless-ts/metadata";
+export type HashType = "md5" | "sha1" | "sha256" | "sha512";
+export declare function inferBytes(resource: Partial<Resource>): Promise<number>;
+export declare function inferHash(resource: Partial<Resource>, options?: {
+    hashType?: HashType;
+}): Promise<string>;
+export declare function inferEncoding(resource: Partial<Resource>, options?: {
+    sampleBytes?: number;
+    confidencePercent?: number;
+}): Promise<string | undefined>;

package/build/file/infer.js

@@ -0,0 +1,48 @@
+import { stat } from "node:fs/promises";
+import chardet from "chardet";
+import * as hasha from "hasha";
+import { isBinaryFile } from "isbinaryfile";
+import pMap from "p-map";
+import { concatFileStreams } from "../stream/concat.js";
+import { loadFileStream } from "../stream/index.js";
+import { prefetchFiles } from "./fetch.js";
+import { loadFile } from "./load.js";
+export async function inferBytes(resource) {
+    const localPaths = await prefetchFiles(resource.path);
+    let bytes = 0;
+    for (const localPath of localPaths) {
+        const result = await stat(localPath);
+        bytes += result.size;
+    }
+    return bytes;
+}
+export async function inferHash(resource, options) {
+    const algorithm = options?.hashType ?? "sha256";
+    const localPaths = await prefetchFiles(resource.path);
+    const streams = await pMap(localPaths, async (path) => loadFileStream(path));
+    const stream = concatFileStreams(streams);
+    const hash = await hasha.hash(stream, { algorithm });
+    return `${algorithm}:${hash}`;
+}
+export async function inferEncoding(resource, options) {
+    const maxBytes = options?.sampleBytes ?? 10_000;
+    const confidencePercent = options?.confidencePercent ?? 80;
+    const firstPath = Array.isArray(resource.path)
+        ? resource.path[0]
+        : resource.path;
+    if (!firstPath) {
+        return undefined;
+    }
+    const buffer = await loadFile(firstPath, { maxBytes });
+    const isBinary = await isBinaryFile(buffer);
+    if (!isBinary) {
+        const matches = chardet.analyse(buffer);
+        for (const match of matches) {
+            if (match.confidence >= confidencePercent) {
+                return match.name.toLowerCase();
+            }
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/file/infer.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/file/infer.spec.js

@@ -0,0 +1,141 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as fetchModule from "./fetch.js";
+import { inferBytes, inferEncoding, inferHash } from "./infer.js";
+import { writeTempFile } from "./temp.js";
+vi.mock("./fetch.ts", () => ({
+    prefetchFiles: vi.fn(),
+}));
+describe("inferHash", () => {
+    let mockPrefetchFiles;
+    let tempFilePath;
+    beforeEach(async () => {
+        mockPrefetchFiles = vi.mocked(fetchModule.prefetchFiles);
+        tempFilePath = await writeTempFile("Hello, World!");
+        vi.clearAllMocks();
+    });
+    it("should compute sha256 hash by default", async () => {
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const result = await inferHash({ path: "https://example.com/file.txt" });
+        expect(mockPrefetchFiles).toHaveBeenCalledWith("https://example.com/file.txt");
+        expect(result).toMatch(/^sha256:[a-f0-9]{64}$/);
+    });
+    it("should compute md5 hash when specified", async () => {
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const result = await inferHash({ path: "https://example.com/file.txt" }, {
+            hashType: "md5",
+        });
+        expect(mockPrefetchFiles).toHaveBeenCalledWith("https://example.com/file.txt");
+        expect(result).toMatch(/^md5:[a-f0-9]{32}$/);
+    });
+    it("should compute sha1 hash when specified", async () => {
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const result = await inferHash({ path: "https://example.com/file.txt" }, {
+            hashType: "sha1",
+        });
+        expect(mockPrefetchFiles).toHaveBeenCalledWith("https://example.com/file.txt");
+        expect(result).toMatch(/^sha1:[a-f0-9]{40}$/);
+    });
+    it("should compute sha512 hash when specified", async () => {
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const result = await inferHash({ path: "https://example.com/file.txt" }, {
+            hashType: "sha512",
+        });
+        expect(mockPrefetchFiles).toHaveBeenCalledWith("https://example.com/file.txt");
+        expect(result).toMatch(/^sha512:[a-f0-9]{128}$/);
+    });
+    it("should compute consistent hashes for same content", async () => {
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const result1 = await inferHash({ path: "https://example.com/file.txt" });
+        const result2 = await inferHash({ path: "https://example.com/file.txt" });
+        expect(result1).toBe(result2);
+    });
+});
+describe("inferBytes", () => {
+    let mockPrefetchFiles;
+    beforeEach(() => {
+        mockPrefetchFiles = vi.mocked(fetchModule.prefetchFiles);
+        vi.clearAllMocks();
+    });
+    it("should return file size in bytes", async () => {
+        const tempFilePath = await writeTempFile("Hello, World!");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const result = await inferBytes({ path: "https://example.com/file.txt" });
+        expect(mockPrefetchFiles).toHaveBeenCalledWith("https://example.com/file.txt");
+        expect(result).toBe(13);
+    });
+    it("should handle empty files", async () => {
+        const tempFilePath = await writeTempFile("");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const result = await inferBytes({ path: "https://example.com/empty.txt" });
+        expect(result).toBe(0);
+    });
+    it("should handle larger files", async () => {
+        const tempFilePath = await writeTempFile("x".repeat(10000));
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const result = await inferBytes({ path: "https://example.com/large.txt" });
+        expect(result).toBe(10000);
+    });
+    it("should handle binary data", async () => {
+        const tempFilePath = await writeTempFile(Buffer.from([0xff, 0xd8, 0xff, 0xe0]));
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const result = await inferBytes({ path: "https://example.com/file.bin" });
+        expect(mockPrefetchFiles).toHaveBeenCalledWith("https://example.com/file.bin");
+        expect(result).toBe(4);
+    });
+});
+describe("inferEncoding", () => {
+    it("should detect utf-8 encoding", async () => {
+        const tempFilePath = await writeTempFile("Hello, World! This is UTF-8 text.");
+        const result = await inferEncoding({ path: tempFilePath });
+        expect(result).toBeDefined();
+        expect(["utf-8", "utf8", "ascii"]).toContain(result);
+    });
+    it("should return undefined for binary files", async () => {
+        const tempFilePath = await writeTempFile(Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00]));
+        const result = await inferEncoding({ path: tempFilePath });
+        expect(result).toBeUndefined();
+    });
+    it("should use custom sample bytes", async () => {
+        const tempFilePath = await writeTempFile("This is a test file with UTF-8 content.");
+        const result = await inferEncoding({ path: tempFilePath }, { sampleBytes: 20 });
+        expect(result).toBeDefined();
+    });
+    it("should use custom confidence threshold", async () => {
+        const tempFilePath = await writeTempFile("Sample text content");
+        const result = await inferEncoding({ path: tempFilePath }, {
+            confidencePercent: 50,
+        });
+        expect(result).toBeDefined();
+    });
+    it("should handle large text files", async () => {
+        const tempFilePath = await writeTempFile("Hello World! ".repeat(1000));
+        const result = await inferEncoding({ path: tempFilePath });
+        expect(result).toBeDefined();
+        expect(["utf-8", "utf8", "ascii"]).toContain(result);
+    });
+    it("should return encoding in lowercase", async () => {
+        const tempFilePath = await writeTempFile("Test content for encoding detection");
+        const result = await inferEncoding({ path: tempFilePath });
+        if (result) {
+            expect(result).toBe(result.toLowerCase());
+        }
+    });
+    it("should handle empty files", async () => {
+        const tempFilePath = await writeTempFile("");
+        const result = await inferEncoding({ path: tempFilePath });
+        expect([undefined, "utf-8", "utf8", "ascii"]).toContain(result);
+    });
+    it("should handle files with special characters", async () => {
+        const tempFilePath = await writeTempFile("Special: é, ñ, ü, ö, à");
+        const result = await inferEncoding({ path: tempFilePath });
+        expect(result).toBeDefined();
+    });
+    it("should detect encoding with low confidence threshold", async () => {
+        const tempFilePath = await writeTempFile("Simple text");
+        const result = await inferEncoding({ path: tempFilePath }, {
+            confidencePercent: 30,
+        });
+        expect(result).toBeDefined();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infer.spec.js","sourceRoot":"","sources":["../../file/infer.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { beforeEach, describe, expect, it, vi } from \"vitest\"\nimport * as fetchModule from \"./fetch.ts\"\nimport { inferBytes, inferEncoding, inferHash } from \"./infer.ts\"\nimport { writeTempFile } from \"./temp.ts\"\n\nvi.mock(\"./fetch.ts\", () => ({\n  prefetchFiles: vi.fn(),\n}))\n\ndescribe(\"inferHash\", () => {\n  let mockPrefetchFiles: ReturnType<typeof vi.fn>\n  let tempFilePath: string\n\n  beforeEach(async () => {\n    mockPrefetchFiles = vi.mocked(fetchModule.prefetchFiles)\n    tempFilePath = await writeTempFile(\"Hello, World!\")\n    vi.clearAllMocks()\n  })\n\n  it(\"should compute sha256 hash by default\", async () => {\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const result = await inferHash({ path: \"https://example.com/file.txt\" })\n\n    expect(mockPrefetchFiles).toHaveBeenCalledWith(\n      \"https://example.com/file.txt\",\n    )\n    expect(result).toMatch(/^sha256:[a-f0-9]{64}$/)\n  })\n\n  it(\"should compute md5 hash when specified\", async () => {\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const result = await inferHash(\n      { path: \"https://example.com/file.txt\" },\n      {\n        hashType: \"md5\",\n      },\n    )\n\n    expect(mockPrefetchFiles).toHaveBeenCalledWith(\n      \"https://example.com/file.txt\",\n    )\n    expect(result).toMatch(/^md5:[a-f0-9]{32}$/)\n  })\n\n  it(\"should compute sha1 hash when specified\", async () => {\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const result = await inferHash(\n      { path: \"https://example.com/file.txt\" },\n      {\n        hashType: \"sha1\",\n      },\n    )\n\n    expect(mockPrefetchFiles).toHaveBeenCalledWith(\n      \"https://example.com/file.txt\",\n    )\n    expect(result).toMatch(/^sha1:[a-f0-9]{40}$/)\n  })\n\n  it(\"should compute sha512 hash when specified\", async () => {\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const result = await inferHash(\n      { path: \"https://example.com/file.txt\" },\n      {\n        hashType: \"sha512\",\n      },\n    )\n\n    expect(mockPrefetchFiles).toHaveBeenCalledWith(\n      \"https://example.com/file.txt\",\n    )\n    expect(result).toMatch(/^sha512:[a-f0-9]{128}$/)\n  })\n\n  it(\"should compute consistent hashes for same content\", async () => {\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const result1 = await inferHash({ path: \"https://example.com/file.txt\" })\n    const result2 = await inferHash({ path: \"https://example.com/file.txt\" })\n\n    expect(result1).toBe(result2)\n  })\n})\n\ndescribe(\"inferBytes\", () => {\n  let mockPrefetchFiles: ReturnType<typeof vi.fn>\n\n  beforeEach(() => {\n    mockPrefetchFiles = vi.mocked(fetchModule.prefetchFiles)\n    vi.clearAllMocks()\n  })\n\n  it(\"should return file size in bytes\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello, World!\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const result = await inferBytes({ path: \"https://example.com/file.txt\" })\n\n    expect(mockPrefetchFiles).toHaveBeenCalledWith(\n      \"https://example.com/file.txt\",\n    )\n    expect(result).toBe(13)\n  })\n\n  it(\"should handle empty files\", async () => {\n    const tempFilePath = await writeTempFile(\"\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const result = await inferBytes({ path: \"https://example.com/empty.txt\" })\n\n    expect(result).toBe(0)\n  })\n\n  it(\"should handle larger files\", async () => {\n    const tempFilePath = await writeTempFile(\"x\".repeat(10000))\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const result = await inferBytes({ path: \"https://example.com/large.txt\" })\n\n    expect(result).toBe(10000)\n  })\n\n  it(\"should handle binary data\", async () => {\n    const tempFilePath = await writeTempFile(\n      Buffer.from([0xff, 0xd8, 0xff, 0xe0]),\n    )\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const result = await inferBytes({ path: \"https://example.com/file.bin\" })\n\n    expect(mockPrefetchFiles).toHaveBeenCalledWith(\n      \"https://example.com/file.bin\",\n    )\n    expect(result).toBe(4)\n  })\n})\n\ndescribe(\"inferEncoding\", () => {\n  it(\"should detect utf-8 encoding\", async () => {\n    const tempFilePath = await writeTempFile(\n      \"Hello, World! This is UTF-8 text.\",\n    )\n\n    const result = await inferEncoding({ path: tempFilePath })\n\n    expect(result).toBeDefined()\n    expect([\"utf-8\", \"utf8\", \"ascii\"]).toContain(result)\n  })\n\n  it(\"should return undefined for binary files\", async () => {\n    const tempFilePath = await writeTempFile(\n      Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00]),\n    )\n\n    const result = await inferEncoding({ path: tempFilePath })\n\n    expect(result).toBeUndefined()\n  })\n\n  it(\"should use custom sample bytes\", async () => {\n    const tempFilePath = await writeTempFile(\n      \"This is a test file with UTF-8 content.\",\n    )\n\n    const result = await inferEncoding(\n      { path: tempFilePath },\n      { sampleBytes: 20 },\n    )\n\n    expect(result).toBeDefined()\n  })\n\n  it(\"should use custom confidence threshold\", async () => {\n    const tempFilePath = await writeTempFile(\"Sample text content\")\n\n    const result = await inferEncoding(\n      { path: tempFilePath },\n      {\n        confidencePercent: 50,\n      },\n    )\n\n    expect(result).toBeDefined()\n  })\n\n  it(\"should handle large text files\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello World! \".repeat(1000))\n\n    const result = await inferEncoding({ path: tempFilePath })\n\n    expect(result).toBeDefined()\n    expect([\"utf-8\", \"utf8\", \"ascii\"]).toContain(result)\n  })\n\n  it(\"should return encoding in lowercase\", async () => {\n    const tempFilePath = await writeTempFile(\n      \"Test content for encoding detection\",\n    )\n\n    const result = await inferEncoding({ path: tempFilePath })\n\n    if (result) {\n      expect(result).toBe(result.toLowerCase())\n    }\n  })\n\n  it(\"should handle empty files\", async () => {\n    const tempFilePath = await writeTempFile(\"\")\n\n    const result = await inferEncoding({ path: tempFilePath })\n\n    expect([undefined, \"utf-8\", \"utf8\", \"ascii\"]).toContain(result)\n  })\n\n  it(\"should handle files with special characters\", async () => {\n    const tempFilePath = await writeTempFile(\"Special: é, ñ, ü, ö, à\")\n\n    const result = await inferEncoding({ path: tempFilePath })\n\n    expect(result).toBeDefined()\n  })\n\n  it(\"should detect encoding with low confidence threshold\", async () => {\n    const tempFilePath = await writeTempFile(\"Simple text\")\n\n    const result = await inferEncoding(\n      { path: tempFilePath },\n      {\n        confidencePercent: 30,\n      },\n    )\n\n    expect(result).toBeDefined()\n  })\n})\n"]}

package/build/file/load.d.ts

@@ -0,0 +1,3 @@
+export declare function loadFile(path: string, options?: {
+    maxBytes?: number;
+}): Promise<Buffer<ArrayBufferLike>>;

package/build/file/load.js

@@ -0,0 +1,7 @@
+import { buffer } from "node:stream/consumers";
+import { loadFileStream } from "../stream/index.js";
+export async function loadFile(path, options) {
+    const stream = await loadFileStream(path, options);
+    return await buffer(stream);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2ZpbGUvbG9hZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUE7QUFDOUMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFBO0FBRW5ELE1BQU0sQ0FBQyxLQUFLLFVBQVUsUUFBUSxDQUFDLElBQVksRUFBRSxPQUErQjtJQUMxRSxNQUFNLE1BQU0sR0FBRyxNQUFNLGNBQWMsQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUE7SUFDbEQsT0FBTyxNQUFNLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQTtBQUM3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYnVmZmVyIH0gZnJvbSBcIm5vZGU6c3RyZWFtL2NvbnN1bWVyc1wiXG5pbXBvcnQgeyBsb2FkRmlsZVN0cmVhbSB9IGZyb20gXCIuLi9zdHJlYW0vaW5kZXgudHNcIlxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gbG9hZEZpbGUocGF0aDogc3RyaW5nLCBvcHRpb25zPzogeyBtYXhCeXRlcz86IG51bWJlciB9KSB7XG4gIGNvbnN0IHN0cmVhbSA9IGF3YWl0IGxvYWRGaWxlU3RyZWFtKHBhdGgsIG9wdGlvbnMpXG4gIHJldHVybiBhd2FpdCBidWZmZXIoc3RyZWFtKVxufVxuIl19

package/build/file/path.d.ts

@@ -0,0 +1,2 @@
+export declare function isLocalPathExist(path: string): Promise<boolean>;
+export declare function assertLocalPathVacant(path: string): Promise<void>;

package/build/file/path.js

@@ -0,0 +1,17 @@
+import { access } from "node:fs/promises";
+export async function isLocalPathExist(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+export async function assertLocalPathVacant(path) {
+    const isExist = await isLocalPathExist(path);
+    if (isExist) {
+        throw new Error(`Path "${path}" already exists`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2ZpbGUvcGF0aC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUE7QUFFekMsTUFBTSxDQUFDLEtBQUssVUFBVSxnQkFBZ0IsQ0FBQyxJQUFZO0lBQ2pELElBQUksQ0FBQztRQUNILE1BQU0sTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFBO1FBQ2xCLE9BQU8sSUFBSSxDQUFBO0lBQ2IsQ0FBQztJQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7UUFDZixPQUFPLEtBQUssQ0FBQTtJQUNkLENBQUM7QUFDSCxDQUFDO0FBRUQsTUFBTSxDQUFDLEtBQUssVUFBVSxxQkFBcUIsQ0FBQyxJQUFZO0lBQ3RELE1BQU0sT0FBTyxHQUFHLE1BQU0sZ0JBQWdCLENBQUMsSUFBSSxDQUFDLENBQUE7SUFFNUMsSUFBSSxPQUFPLEVBQUUsQ0FBQztRQUNaLE1BQU0sSUFBSSxLQUFLLENBQUMsU0FBUyxJQUFJLGtCQUFrQixDQUFDLENBQUE7SUFDbEQsQ0FBQztBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBhY2Nlc3MgfSBmcm9tIFwibm9kZTpmcy9wcm9taXNlc1wiXG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBpc0xvY2FsUGF0aEV4aXN0KHBhdGg6IHN0cmluZykge1xuICB0cnkge1xuICAgIGF3YWl0IGFjY2VzcyhwYXRoKVxuICAgIHJldHVybiB0cnVlXG4gIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgcmV0dXJuIGZhbHNlXG4gIH1cbn1cblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGFzc2VydExvY2FsUGF0aFZhY2FudChwYXRoOiBzdHJpbmcpIHtcbiAgY29uc3QgaXNFeGlzdCA9IGF3YWl0IGlzTG9jYWxQYXRoRXhpc3QocGF0aClcblxuICBpZiAoaXNFeGlzdCkge1xuICAgIHRocm93IG5ldyBFcnJvcihgUGF0aCBcIiR7cGF0aH1cIiBhbHJlYWR5IGV4aXN0c2ApXG4gIH1cbn1cbiJdfQ==

package/build/file/save.d.ts

@@ -0,0 +1,3 @@
+export declare function saveFile(path: string, buffer: Buffer, options?: {
+    overwrite?: boolean;
+}): Promise<void>;

package/build/file/save.js

@@ -0,0 +1,7 @@
+import { Readable } from "node:stream";
+import { saveFileStream } from "../stream/index.js";
+export async function saveFile(path, buffer, options) {
+    const { overwrite } = options ?? {};
+    await saveFileStream(Readable.from(buffer), { path, overwrite });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2F2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2ZpbGUvc2F2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sYUFBYSxDQUFBO0FBQ3RDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQTtBQUVuRCxNQUFNLENBQUMsS0FBSyxVQUFVLFFBQVEsQ0FDNUIsSUFBWSxFQUNaLE1BQWMsRUFDZCxPQUFpQztJQUVqQyxNQUFNLEVBQUUsU0FBUyxFQUFFLEdBQUcsT0FBTyxJQUFJLEVBQUUsQ0FBQTtJQUVuQyxNQUFNLGNBQWMsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUE7QUFDbEUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJlYWRhYmxlIH0gZnJvbSBcIm5vZGU6c3RyZWFtXCJcbmltcG9ydCB7IHNhdmVGaWxlU3RyZWFtIH0gZnJvbSBcIi4uL3N0cmVhbS9pbmRleC50c1wiXG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBzYXZlRmlsZShcbiAgcGF0aDogc3RyaW5nLFxuICBidWZmZXI6IEJ1ZmZlcixcbiAgb3B0aW9ucz86IHsgb3ZlcndyaXRlPzogYm9vbGVhbiB9LFxuKSB7XG4gIGNvbnN0IHsgb3ZlcndyaXRlIH0gPSBvcHRpb25zID8/IHt9XG5cbiAgYXdhaXQgc2F2ZUZpbGVTdHJlYW0oUmVhZGFibGUuZnJvbShidWZmZXIpLCB7IHBhdGgsIG92ZXJ3cml0ZSB9KVxufVxuIl19

package/build/file/temp.d.ts

@@ -0,0 +1,11 @@
+import type { Buffer } from "node:buffer";
+export declare function writeTempFile(content: string | Buffer, options?: {
+    persist?: boolean;
+    filename?: string;
+    format?: string;
+}): Promise<string>;
+export declare function getTempFilePath(options?: {
+    persist?: boolean;
+    filename?: string;
+    format?: string;
+}): string;

package/build/file/temp.js

@@ -0,0 +1,23 @@
+import { unlinkSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import exitHook from "exit-hook";
+import { temporaryFile } from "tempy";
+export async function writeTempFile(content, options) {
+    const path = getTempFilePath(options);
+    await writeFile(path, content);
+    return path;
+}
+export function getTempFilePath(options) {
+    const { filename, format } = options ?? {};
+    const path = temporaryFile(filename ? { name: filename } : { extension: format });
+    if (!options?.persist) {
+        exitHook(() => {
+            try {
+                unlinkSync(path);
+            }
+            catch { }
+        });
+    }
+    return path;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/file/validate.d.ts

@@ -0,0 +1,6 @@
+import type { FileError } from "@frictionless-ts/metadata";
+import type { Resource } from "@frictionless-ts/metadata";
+export declare function validateFile(resource: Partial<Resource>): Promise<{
+    errors: FileError[];
+    valid: boolean;
+}>;