@frictionless-ts/dataset 1.0.1

package/build/file/validate.js

@@ -0,0 +1,47 @@
+import { createReport } from "@frictionless-ts/metadata";
+import { prefetchFiles } from "./fetch.js";
+import { inferBytes, inferEncoding, inferHash } from "./infer.js";
+export async function validateFile(resource) {
+    const errors = [];
+    const localPaths = await prefetchFiles(resource.path);
+    if (resource.bytes) {
+        const bytes = resource.bytes;
+        const actualBytes = await inferBytes({ path: localPaths });
+        if (bytes !== actualBytes) {
+            errors.push({
+                type: "file/bytes",
+                bytes,
+                actualBytes,
+            });
+        }
+    }
+    if (resource.hash) {
+        const [hashValue, hashType = "md5"] = resource.hash.split(":").toReversed();
+        const hash = `${hashType}:${hashValue}`;
+        const actualHash = await inferHash({ path: localPaths }, {
+            hashType: hashType,
+        });
+        if (hash !== actualHash) {
+            errors.push({
+                type: "file/hash",
+                hash,
+                actualHash,
+            });
+        }
+    }
+    if (resource.encoding) {
+        const encoding = resource.encoding;
+        const actualEncoding = await inferEncoding({ path: localPaths });
+        if (actualEncoding) {
+            if (encoding !== actualEncoding) {
+                errors.push({
+                    type: "file/encoding",
+                    encoding,
+                    actualEncoding,
+                });
+            }
+        }
+    }
+    return createReport(errors);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/build/file/validate.spec.js

@@ -0,0 +1,180 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as fetchModule from "./fetch.js";
+import { inferHash } from "./infer.js";
+import { writeTempFile } from "./temp.js";
+import { validateFile } from "./validate.js";
+vi.mock("./fetch.ts", () => ({
+    prefetchFiles: vi.fn(),
+}));
+describe("validateFile", () => {
+    let mockPrefetchFiles;
+    beforeEach(() => {
+        mockPrefetchFiles = vi.mocked(fetchModule.prefetchFiles);
+        vi.clearAllMocks();
+    });
+    it("should return valid report when no validation options provided", async () => {
+        const tempFilePath = await writeTempFile("Hello, World!");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const report = await validateFile({ path: "https://example.com/file.txt" });
+        expect(mockPrefetchFiles).toHaveBeenCalledWith("https://example.com/file.txt");
+        expect(report).toEqual({ valid: true, errors: [] });
+    });
+    it("should validate bytes successfully when they match", async () => {
+        const tempFilePath = await writeTempFile("Hello, World!");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const report = await validateFile({
+            path: "https://example.com/file.txt",
+            bytes: 13,
+        });
+        expect(report).toEqual({ valid: true, errors: [] });
+    });
+    it("should return error when bytes do not match", async () => {
+        const tempFilePath = await writeTempFile("Hello, World!");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const report = await validateFile({
+            path: "https://example.com/file.txt",
+            bytes: 1024,
+        });
+        expect(report.valid).toBe(false);
+        expect(report.errors).toHaveLength(1);
+        expect(report.errors[0]).toEqual({
+            type: "file/bytes",
+            bytes: 1024,
+            actualBytes: 13,
+        });
+    });
+    it("should validate hash successfully when it matches", async () => {
+        const tempFilePath = await writeTempFile("Hello, World!");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const actualHash = await inferHash({ path: tempFilePath }, { hashType: "md5" });
+        const report = await validateFile({
+            path: "https://example.com/file.txt",
+            hash: actualHash,
+        });
+        expect(report).toEqual({ valid: true, errors: [] });
+    });
+    it("should return error when hash does not match", async () => {
+        const tempFilePath = await writeTempFile("Hello, World!");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const actualHash = await inferHash({ path: tempFilePath }, { hashType: "md5" });
+        const report = await validateFile({
+            path: "https://example.com/file.txt",
+            hash: "md5:wronghash",
+        });
+        expect(report.valid).toBe(false);
+        expect(report.errors).toHaveLength(1);
+        expect(report.errors[0]).toEqual({
+            type: "file/hash",
+            hash: "md5:wronghash",
+            actualHash,
+        });
+    });
+    it("should validate sha256 hash", async () => {
+        const tempFilePath = await writeTempFile("Hello, World!");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const actualHash = await inferHash({ path: tempFilePath }, { hashType: "sha256" });
+        const report = await validateFile({
+            path: "https://example.com/file.txt",
+            hash: actualHash,
+        });
+        expect(report).toEqual({ valid: true, errors: [] });
+    });
+    it("should validate sha1 hash", async () => {
+        const tempFilePath = await writeTempFile("Hello, World!");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const actualHash = await inferHash({ path: tempFilePath }, { hashType: "sha1" });
+        const report = await validateFile({
+            path: "https://example.com/file.txt",
+            hash: actualHash,
+        });
+        expect(report).toEqual({ valid: true, errors: [] });
+    });
+    it("should validate sha512 hash", async () => {
+        const tempFilePath = await writeTempFile("Hello, World!");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const actualHash = await inferHash({ path: tempFilePath }, { hashType: "sha512" });
+        const report = await validateFile({
+            path: "https://example.com/file.txt",
+            hash: actualHash,
+        });
+        expect(report).toEqual({ valid: true, errors: [] });
+    });
+    it("should validate both bytes and hash when both match", async () => {
+        const tempFilePath = await writeTempFile("Hello, World!");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const actualHash = await inferHash({ path: tempFilePath }, { hashType: "md5" });
+        const report = await validateFile({
+            path: "https://example.com/file.txt",
+            bytes: 13,
+            hash: actualHash,
+        });
+        expect(report).toEqual({ valid: true, errors: [] });
+    });
+    it("should return multiple errors when both bytes and hash do not match", async () => {
+        const tempFilePath = await writeTempFile("Hello, World!");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const actualHash = await inferHash({ path: tempFilePath }, { hashType: "md5" });
+        const report = await validateFile({
+            path: "https://example.com/file.txt",
+            bytes: 1024,
+            hash: "md5:wronghash",
+        });
+        expect(report.valid).toBe(false);
+        expect(report.errors).toHaveLength(2);
+        expect(report.errors[0]).toEqual({
+            type: "file/bytes",
+            bytes: 1024,
+            actualBytes: 13,
+        });
+        expect(report.errors[1]).toEqual({
+            type: "file/hash",
+            hash: "md5:wronghash",
+            actualHash,
+        });
+    });
+    it("should return error when only bytes mismatch", async () => {
+        const tempFilePath = await writeTempFile("Hello, World!");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const actualHash = await inferHash({ path: tempFilePath }, { hashType: "md5" });
+        const report = await validateFile({
+            path: "https://example.com/file.txt",
+            bytes: 1024,
+            hash: actualHash,
+        });
+        expect(report.valid).toBe(false);
+        expect(report.errors).toHaveLength(1);
+        expect(report.errors[0]?.type).toBe("file/bytes");
+    });
+    it("should return error when only hash mismatch", async () => {
+        const tempFilePath = await writeTempFile("Hello, World!");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const report = await validateFile({
+            path: "https://example.com/file.txt",
+            bytes: 13,
+            hash: "md5:wronghash",
+        });
+        expect(report.valid).toBe(false);
+        expect(report.errors).toHaveLength(1);
+        expect(report.errors[0]?.type).toBe("file/hash");
+    });
+    it("should handle local file paths", async () => {
+        const tempFilePath = await writeTempFile("x".repeat(2048));
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const report = await validateFile({
+            path: "/local/path/file.txt",
+            bytes: 2048,
+        });
+        expect(mockPrefetchFiles).toHaveBeenCalledWith("/local/path/file.txt");
+        expect(report).toEqual({ valid: true, errors: [] });
+    });
+    it("should handle empty file validation", async () => {
+        const tempFilePath = await writeTempFile("");
+        mockPrefetchFiles.mockResolvedValue([tempFilePath]);
+        const report = await validateFile({
+            path: "https://example.com/empty.txt",
+            bytes: 0,
+        });
+        expect(report).toEqual({ valid: true, errors: [] });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate.spec.js","sourceRoot":"","sources":["../../file/validate.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { beforeEach, describe, expect, it, vi } from \"vitest\"\nimport * as fetchModule from \"./fetch.ts\"\nimport { inferHash } from \"./infer.ts\"\nimport { writeTempFile } from \"./temp.ts\"\nimport { validateFile } from \"./validate.ts\"\n\nvi.mock(\"./fetch.ts\", () => ({\n  prefetchFiles: vi.fn(),\n}))\n\ndescribe(\"validateFile\", () => {\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 valid report when no validation options provided\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello, World!\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const report = await validateFile({ path: \"https://example.com/file.txt\" })\n\n    expect(mockPrefetchFiles).toHaveBeenCalledWith(\n      \"https://example.com/file.txt\",\n    )\n    expect(report).toEqual({ valid: true, errors: [] })\n  })\n\n  it(\"should validate bytes successfully when they match\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello, World!\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const report = await validateFile({\n      path: \"https://example.com/file.txt\",\n      bytes: 13,\n    })\n\n    expect(report).toEqual({ valid: true, errors: [] })\n  })\n\n  it(\"should return error when bytes do not match\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello, World!\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const report = await validateFile({\n      path: \"https://example.com/file.txt\",\n      bytes: 1024,\n    })\n\n    expect(report.valid).toBe(false)\n    expect(report.errors).toHaveLength(1)\n    expect(report.errors[0]).toEqual({\n      type: \"file/bytes\",\n      bytes: 1024,\n      actualBytes: 13,\n    })\n  })\n\n  it(\"should validate hash successfully when it matches\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello, World!\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const actualHash = await inferHash(\n      { path: tempFilePath },\n      { hashType: \"md5\" },\n    )\n\n    const report = await validateFile({\n      path: \"https://example.com/file.txt\",\n      hash: actualHash,\n    })\n\n    expect(report).toEqual({ valid: true, errors: [] })\n  })\n\n  it(\"should return error when hash does not match\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello, World!\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const actualHash = await inferHash(\n      { path: tempFilePath },\n      { hashType: \"md5\" },\n    )\n\n    const report = await validateFile({\n      path: \"https://example.com/file.txt\",\n      hash: \"md5:wronghash\",\n    })\n\n    expect(report.valid).toBe(false)\n    expect(report.errors).toHaveLength(1)\n    expect(report.errors[0]).toEqual({\n      type: \"file/hash\",\n      hash: \"md5:wronghash\",\n      actualHash,\n    })\n  })\n\n  it(\"should validate sha256 hash\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello, World!\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const actualHash = await inferHash(\n      { path: tempFilePath },\n      { hashType: \"sha256\" },\n    )\n\n    const report = await validateFile({\n      path: \"https://example.com/file.txt\",\n      hash: actualHash,\n    })\n\n    expect(report).toEqual({ valid: true, errors: [] })\n  })\n\n  it(\"should validate sha1 hash\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello, World!\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const actualHash = await inferHash(\n      { path: tempFilePath },\n      { hashType: \"sha1\" },\n    )\n\n    const report = await validateFile({\n      path: \"https://example.com/file.txt\",\n      hash: actualHash,\n    })\n\n    expect(report).toEqual({ valid: true, errors: [] })\n  })\n\n  it(\"should validate sha512 hash\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello, World!\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const actualHash = await inferHash(\n      { path: tempFilePath },\n      { hashType: \"sha512\" },\n    )\n\n    const report = await validateFile({\n      path: \"https://example.com/file.txt\",\n      hash: actualHash,\n    })\n\n    expect(report).toEqual({ valid: true, errors: [] })\n  })\n\n  it(\"should validate both bytes and hash when both match\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello, World!\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const actualHash = await inferHash(\n      { path: tempFilePath },\n      { hashType: \"md5\" },\n    )\n\n    const report = await validateFile({\n      path: \"https://example.com/file.txt\",\n      bytes: 13,\n      hash: actualHash,\n    })\n\n    expect(report).toEqual({ valid: true, errors: [] })\n  })\n\n  it(\"should return multiple errors when both bytes and hash do not match\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello, World!\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const actualHash = await inferHash(\n      { path: tempFilePath },\n      { hashType: \"md5\" },\n    )\n\n    const report = await validateFile({\n      path: \"https://example.com/file.txt\",\n      bytes: 1024,\n      hash: \"md5:wronghash\",\n    })\n\n    expect(report.valid).toBe(false)\n    expect(report.errors).toHaveLength(2)\n    expect(report.errors[0]).toEqual({\n      type: \"file/bytes\",\n      bytes: 1024,\n      actualBytes: 13,\n    })\n    expect(report.errors[1]).toEqual({\n      type: \"file/hash\",\n      hash: \"md5:wronghash\",\n      actualHash,\n    })\n  })\n\n  it(\"should return error when only bytes mismatch\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello, World!\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const actualHash = await inferHash(\n      { path: tempFilePath },\n      { hashType: \"md5\" },\n    )\n\n    const report = await validateFile({\n      path: \"https://example.com/file.txt\",\n      bytes: 1024,\n      hash: actualHash,\n    })\n\n    expect(report.valid).toBe(false)\n    expect(report.errors).toHaveLength(1)\n    expect(report.errors[0]?.type).toBe(\"file/bytes\")\n  })\n\n  it(\"should return error when only hash mismatch\", async () => {\n    const tempFilePath = await writeTempFile(\"Hello, World!\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const report = await validateFile({\n      path: \"https://example.com/file.txt\",\n      bytes: 13,\n      hash: \"md5:wronghash\",\n    })\n\n    expect(report.valid).toBe(false)\n    expect(report.errors).toHaveLength(1)\n    expect(report.errors[0]?.type).toBe(\"file/hash\")\n  })\n\n  it(\"should handle local file paths\", async () => {\n    const tempFilePath = await writeTempFile(\"x\".repeat(2048))\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const report = await validateFile({\n      path: \"/local/path/file.txt\",\n      bytes: 2048,\n    })\n\n    expect(mockPrefetchFiles).toHaveBeenCalledWith(\"/local/path/file.txt\")\n    expect(report).toEqual({ valid: true, errors: [] })\n  })\n\n  it(\"should handle empty file validation\", async () => {\n    const tempFilePath = await writeTempFile(\"\")\n    mockPrefetchFiles.mockResolvedValue([tempFilePath])\n\n    const report = await validateFile({\n      path: \"https://example.com/empty.txt\",\n      bytes: 0,\n    })\n\n    expect(report).toEqual({ valid: true, errors: [] })\n  })\n})\n"]}

package/build/folder/create.d.ts

@@ -0,0 +1 @@
+export declare function createFolder(path: string): Promise<void>;

package/build/folder/create.js

@@ -0,0 +1,5 @@
+import { mkdir } from "node:fs/promises";
+export async function createFolder(path) {
+    await mkdir(path, { recursive: true });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vZm9sZGVyL2NyZWF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sa0JBQWtCLENBQUE7QUFFeEMsTUFBTSxDQUFDLEtBQUssVUFBVSxZQUFZLENBQUMsSUFBWTtJQUM3QyxNQUFNLEtBQUssQ0FBQyxJQUFJLEVBQUUsRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQTtBQUN4QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbWtkaXIgfSBmcm9tIFwibm9kZTpmcy9wcm9taXNlc1wiXG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBjcmVhdGVGb2xkZXIocGF0aDogc3RyaW5nKSB7XG4gIGF3YWl0IG1rZGlyKHBhdGgsIHsgcmVjdXJzaXZlOiB0cnVlIH0pXG59XG4iXX0=

package/build/folder/index.d.ts

@@ -0,0 +1,2 @@
+export { createFolder } from "./create.ts";
+export { getTempFolderPath } from "./temp.ts";

package/build/folder/index.js

@@ -0,0 +1,3 @@
+export { createFolder } from "./create.js";
+export { getTempFolderPath } from "./temp.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9mb2xkZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUMxQyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxXQUFXLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBjcmVhdGVGb2xkZXIgfSBmcm9tIFwiLi9jcmVhdGUudHNcIlxuZXhwb3J0IHsgZ2V0VGVtcEZvbGRlclBhdGggfSBmcm9tIFwiLi90ZW1wLnRzXCJcbiJdfQ==

package/build/folder/temp.d.ts

@@ -0,0 +1,3 @@
+export declare function getTempFolderPath(options?: {
+    persist?: boolean;
+}): string;

package/build/folder/temp.js

@@ -0,0 +1,16 @@
+import { rmSync } from "node:fs";
+import exitHook from "exit-hook";
+import { temporaryDirectory } from "tempy";
+export function getTempFolderPath(options) {
+    const path = temporaryDirectory();
+    if (!options?.persist) {
+        exitHook(() => {
+            try {
+                rmSync(path, { recursive: true, force: true });
+            }
+            catch { }
+        });
+    }
+    return path;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2ZvbGRlci90ZW1wLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxTQUFTLENBQUE7QUFDaEMsT0FBTyxRQUFRLE1BQU0sV0FBVyxDQUFBO0FBQ2hDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLE9BQU8sQ0FBQTtBQUUxQyxNQUFNLFVBQVUsaUJBQWlCLENBQUMsT0FBK0I7SUFDL0QsTUFBTSxJQUFJLEdBQUcsa0JBQWtCLEVBQUUsQ0FBQTtJQUVqQyxJQUFJLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDO1FBQ3RCLFFBQVEsQ0FBQyxHQUFHLEVBQUU7WUFDWixJQUFJLENBQUM7Z0JBQ0gsTUFBTSxDQUFDLElBQUksRUFBRSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUE7WUFDaEQsQ0FBQztZQUFDLE1BQU0sQ0FBQyxDQUFBLENBQUM7UUFDWixDQUFDLENBQUMsQ0FBQTtJQUNKLENBQUM7SUFFRCxPQUFPLElBQUksQ0FBQTtBQUNiLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBybVN5bmMgfSBmcm9tIFwibm9kZTpmc1wiXG5pbXBvcnQgZXhpdEhvb2sgZnJvbSBcImV4aXQtaG9va1wiXG5pbXBvcnQgeyB0ZW1wb3JhcnlEaXJlY3RvcnkgfSBmcm9tIFwidGVtcHlcIlxuXG5leHBvcnQgZnVuY3Rpb24gZ2V0VGVtcEZvbGRlclBhdGgob3B0aW9ucz86IHsgcGVyc2lzdD86IGJvb2xlYW4gfSkge1xuICBjb25zdCBwYXRoID0gdGVtcG9yYXJ5RGlyZWN0b3J5KClcblxuICBpZiAoIW9wdGlvbnM/LnBlcnNpc3QpIHtcbiAgICBleGl0SG9vaygoKSA9PiB7XG4gICAgICB0cnkge1xuICAgICAgICBybVN5bmMocGF0aCwgeyByZWN1cnNpdmU6IHRydWUsIGZvcmNlOiB0cnVlIH0pXG4gICAgICB9IGNhdGNoIHt9XG4gICAgfSlcbiAgfVxuXG4gIHJldHVybiBwYXRoXG59XG4iXX0=

package/build/index.d.ts

@@ -0,0 +1,36 @@
+export type { DatasetPlugin } from "./plugin.ts";
+export type { SavePackageOptions } from "./plugin.ts";
+export { CkanPlugin } from "./plugins/ckan/index.ts";
+export { DatahubPlugin } from "./plugins/datahub/index.ts";
+export { DescriptorPlugin } from "./plugins/descriptor/index.ts";
+export { FolderPlugin } from "./plugins/folder/index.ts";
+export { GithubPlugin } from "./plugins/github/index.ts";
+export { ZenodoPlugin } from "./plugins/zenodo/index.ts";
+export { ZipPlugin } from "./plugins/zip/index.ts";
+export { assertLocalPathVacant } from "./file/index.ts";
+export { copyFile } from "./file/index.ts";
+export { describeFile } from "./file/index.ts";
+export { getTempFilePath } from "./file/index.ts";
+export { getTempFolderPath } from "./folder/index.ts";
+export { inferBytes } from "./file/index.ts";
+export { inferEncoding } from "./file/index.ts";
+export { inferHash } from "./file/index.ts";
+export { isLocalPathExist } from "./file/index.ts";
+export { loadFile } from "./file/index.ts";
+export { loadFileStream } from "./stream/index.ts";
+export { loadPackageFromCkan } from "./plugins/ckan/index.ts";
+export { loadPackageFromDatahub } from "./plugins/datahub/index.ts";
+export { loadPackageFromFolder } from "./plugins/folder/index.ts";
+export { loadPackageFromGithub } from "./plugins/github/index.ts";
+export { loadPackageFromZenodo } from "./plugins/zenodo/index.ts";
+export { loadPackageFromZip } from "./plugins/zip/index.ts";
+export { prefetchFile } from "./file/index.ts";
+export { prefetchFiles } from "./file/index.ts";
+export { saveFile } from "./file/index.ts";
+export { savePackageToCkan } from "./plugins/ckan/index.ts";
+export { savePackageToFolder } from "./plugins/folder/index.ts";
+export { savePackageToGithub } from "./plugins/github/index.ts";
+export { savePackageToZenodo } from "./plugins/zenodo/index.ts";
+export { savePackageToZip } from "./plugins/zip/index.ts";
+export { validateFile } from "./file/index.ts";
+export { writeTempFile } from "./file/index.ts";

package/build/index.js

@@ -0,0 +1,35 @@
+export { CkanPlugin } from "./plugins/ckan/index.js";
+export { DatahubPlugin } from "./plugins/datahub/index.js";
+export { DescriptorPlugin } from "./plugins/descriptor/index.js";
+export { FolderPlugin } from "./plugins/folder/index.js";
+export { GithubPlugin } from "./plugins/github/index.js";
+export { ZenodoPlugin } from "./plugins/zenodo/index.js";
+export { ZipPlugin } from "./plugins/zip/index.js";
+export { assertLocalPathVacant } from "./file/index.js";
+export { copyFile } from "./file/index.js";
+export { describeFile } from "./file/index.js";
+export { getTempFilePath } from "./file/index.js";
+export { getTempFolderPath } from "./folder/index.js";
+export { inferBytes } from "./file/index.js";
+export { inferEncoding } from "./file/index.js";
+export { inferHash } from "./file/index.js";
+export { isLocalPathExist } from "./file/index.js";
+export { loadFile } from "./file/index.js";
+export { loadFileStream } from "./stream/index.js";
+export { loadPackageFromCkan } from "./plugins/ckan/index.js";
+export { loadPackageFromDatahub } from "./plugins/datahub/index.js";
+export { loadPackageFromFolder } from "./plugins/folder/index.js";
+export { loadPackageFromGithub } from "./plugins/github/index.js";
+export { loadPackageFromZenodo } from "./plugins/zenodo/index.js";
+export { loadPackageFromZip } from "./plugins/zip/index.js";
+export { prefetchFile } from "./file/index.js";
+export { prefetchFiles } from "./file/index.js";
+export { saveFile } from "./file/index.js";
+export { savePackageToCkan } from "./plugins/ckan/index.js";
+export { savePackageToFolder } from "./plugins/folder/index.js";
+export { savePackageToGithub } from "./plugins/github/index.js";
+export { savePackageToZenodo } from "./plugins/zenodo/index.js";
+export { savePackageToZip } from "./plugins/zip/index.js";
+export { validateFile } from "./file/index.js";
+export { writeTempFile } from "./file/index.js";
+//# sourceMappingURL=data:application/json;base64,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

package/build/package/index.d.ts

@@ -0,0 +1,2 @@
+export { getPackageBasepath } from "./path.ts";
+export { mergePackages } from "./merge.ts";

package/build/package/index.js

@@ -0,0 +1,3 @@
+export { getPackageBasepath } from "./path.js";
+export { mergePackages } from "./merge.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9wYWNrYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUM5QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sWUFBWSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgZ2V0UGFja2FnZUJhc2VwYXRoIH0gZnJvbSBcIi4vcGF0aC50c1wiXG5leHBvcnQgeyBtZXJnZVBhY2thZ2VzIH0gZnJvbSBcIi4vbWVyZ2UudHNcIlxuIl19

package/build/package/merge.d.ts

@@ -0,0 +1,23 @@
+import type { Package } from "@frictionless-ts/metadata";
+/**
+ * Merges a system data package into a user data package if provided
+ */
+export declare function mergePackages(options: {
+    systemPackage: Package;
+    userPackagePath?: string;
+}): Promise<{
+    [x: `${string}:${string}`]: any;
+    $schema?: string;
+    resources: import("@frictionless-ts/metadata").Resource[];
+    name?: string;
+    title?: string;
+    description?: string;
+    homepage?: string;
+    version?: string;
+    licenses?: import("@frictionless-ts/metadata").License[];
+    contributors?: import("@frictionless-ts/metadata").Contributor[];
+    sources?: import("@frictionless-ts/metadata").Source[];
+    keywords?: string[];
+    created?: string;
+    image?: string;
+}>;

package/build/package/merge.js

@@ -0,0 +1,12 @@
+import { loadPackageDescriptor } from "@frictionless-ts/metadata";
+/**
+ * Merges a system data package into a user data package if provided
+ */
+export async function mergePackages(options) {
+    const systemPackage = options.systemPackage;
+    const userPackage = options.userPackagePath
+        ? await loadPackageDescriptor(options.userPackagePath)
+        : undefined;
+    return { ...systemPackage, ...userPackage };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVyZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9wYWNrYWdlL21lcmdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFBO0FBRWpFOztHQUVHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxhQUFhLENBQUMsT0FHbkM7SUFDQyxNQUFNLGFBQWEsR0FBRyxPQUFPLENBQUMsYUFBYSxDQUFBO0lBRTNDLE1BQU0sV0FBVyxHQUFHLE9BQU8sQ0FBQyxlQUFlO1FBQ3pDLENBQUMsQ0FBQyxNQUFNLHFCQUFxQixDQUFDLE9BQU8sQ0FBQyxlQUFlLENBQUM7UUFDdEQsQ0FBQyxDQUFDLFNBQVMsQ0FBQTtJQUViLE9BQU8sRUFBRSxHQUFHLGFBQWEsRUFBRSxHQUFHLFdBQVcsRUFBRSxDQUFBO0FBQzdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFBhY2thZ2UgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy9tZXRhZGF0YVwiXG5pbXBvcnQgeyBsb2FkUGFja2FnZURlc2NyaXB0b3IgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy9tZXRhZGF0YVwiXG5cbi8qKlxuICogTWVyZ2VzIGEgc3lzdGVtIGRhdGEgcGFja2FnZSBpbnRvIGEgdXNlciBkYXRhIHBhY2thZ2UgaWYgcHJvdmlkZWRcbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIG1lcmdlUGFja2FnZXMob3B0aW9uczoge1xuICBzeXN0ZW1QYWNrYWdlOiBQYWNrYWdlXG4gIHVzZXJQYWNrYWdlUGF0aD86IHN0cmluZ1xufSkge1xuICBjb25zdCBzeXN0ZW1QYWNrYWdlID0gb3B0aW9ucy5zeXN0ZW1QYWNrYWdlXG5cbiAgY29uc3QgdXNlclBhY2thZ2UgPSBvcHRpb25zLnVzZXJQYWNrYWdlUGF0aFxuICAgID8gYXdhaXQgbG9hZFBhY2thZ2VEZXNjcmlwdG9yKG9wdGlvbnMudXNlclBhY2thZ2VQYXRoKVxuICAgIDogdW5kZWZpbmVkXG5cbiAgcmV0dXJuIHsgLi4uc3lzdGVtUGFja2FnZSwgLi4udXNlclBhY2thZ2UgfVxufVxuIl19

package/build/package/path.d.ts

@@ -0,0 +1,3 @@
+import { type Package } from "@frictionless-ts/metadata";
+export declare function getPackageBasepath(dataPackage: Package): string | undefined;
+export declare function getCommonLocalBasepath(paths: string[]): string | undefined;

package/build/package/path.js

@@ -0,0 +1,43 @@
+import { join, relative, resolve, sep } from "node:path";
+import { getBasepath, isRemotePath, } from "@frictionless-ts/metadata";
+export function getPackageBasepath(dataPackage) {
+    const paths = [];
+    for (const resource of dataPackage.resources) {
+        if (!resource.path) {
+            continue;
+        }
+        const resourcePaths = Array.isArray(resource.path)
+            ? resource.path
+            : [resource.path];
+        paths.push(...resourcePaths);
+    }
+    return getCommonLocalBasepath(paths);
+}
+export function getCommonLocalBasepath(paths) {
+    const absoluteBasepaths = paths
+        .filter(path => !isRemotePath(path))
+        .map(path => resolve(getBasepath(path)));
+    if (!absoluteBasepaths.length) {
+        return undefined;
+    }
+    // On Unix it split the root fs as an empty segment
+    const segmentTable = absoluteBasepaths.map(path => path.split(sep).map(segment => segment || "/"));
+    let column = 0;
+    const segments = [];
+    while (true) {
+        const segmentColumn = segmentTable.map(segments => segments[column]);
+        const uniqueSegments = new Set(segmentColumn);
+        if (uniqueSegments.size !== 1)
+            break;
+        if (!segmentColumn[0])
+            break;
+        column++;
+        segments.push(segmentColumn[0]);
+    }
+    if (!segments.length) {
+        throw new Error("Cannot find common basepath");
+    }
+    const basepath = relative(process.cwd(), join(...segments));
+    return basepath;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/package/path.spec.d.ts

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

package/build/package/path.spec.js

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { getCommonLocalBasepath } from "./path.js";
+describe("getCommonLocalBasepath", () => {
+    it.each([
+        {
+            description: "same directory different files",
+            paths: ["data/table1.csv", "data/table2.csv"],
+            basepath: "data",
+        },
+        {
+            description: "nested directories",
+            paths: [
+                "data/nested/file1.csv",
+                "data/nested/file2.csv",
+                "data/file3.csv",
+            ],
+            basepath: "data",
+        },
+        {
+            description: "single path",
+            paths: ["data/file.csv"],
+            basepath: "data",
+        },
+        {
+            description: "root level files",
+            paths: ["file1.csv", "file2.csv"],
+            basepath: "",
+        },
+        {
+            description: "different top-level directories",
+            paths: ["data1/file1.csv", "data2/file2.csv"],
+            basepath: "",
+        },
+        {
+            description: "empty paths array",
+            paths: [],
+            basepath: undefined,
+        },
+        {
+            description: "some path are remote",
+            paths: ["https://example.com/table.csv", "data/table.csv"],
+            basepath: "data",
+        },
+        {
+            description: "all paths are remote",
+            paths: [
+                "https://example.com/table1.csv",
+                "https://example.com/table2.csv",
+            ],
+            basepath: undefined,
+        },
+    ])("$description", ({ paths, basepath }) => {
+        expect(getCommonLocalBasepath(paths)).toEqual(basepath);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/plugin.d.ts

@@ -0,0 +1,11 @@
+import type { Package } from "@frictionless-ts/metadata";
+export type SavePackageOptions = {
+    target: string;
+    withRemote?: boolean;
+};
+export interface DatasetPlugin {
+    loadPackage?(source: string): Promise<Package | undefined>;
+    savePackage?(dataPackage: Package, options: SavePackageOptions): Promise<{
+        path?: string;
+    } | undefined>;
+}

package/build/plugin.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vcGx1Z2luLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFBhY2thZ2UgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy9tZXRhZGF0YVwiXG5cbmV4cG9ydCB0eXBlIFNhdmVQYWNrYWdlT3B0aW9ucyA9IHtcbiAgdGFyZ2V0OiBzdHJpbmdcbiAgd2l0aFJlbW90ZT86IGJvb2xlYW5cbn1cblxuZXhwb3J0IGludGVyZmFjZSBEYXRhc2V0UGx1Z2luIHtcbiAgbG9hZFBhY2thZ2U/KHNvdXJjZTogc3RyaW5nKTogUHJvbWlzZTxQYWNrYWdlIHwgdW5kZWZpbmVkPlxuXG4gIHNhdmVQYWNrYWdlPyhcbiAgICBkYXRhUGFja2FnZTogUGFja2FnZSxcbiAgICBvcHRpb25zOiBTYXZlUGFja2FnZU9wdGlvbnMsXG4gICk6IFByb21pc2U8eyBwYXRoPzogc3RyaW5nIH0gfCB1bmRlZmluZWQ+XG59XG4iXX0=

package/build/plugins/ckan/ckan/index.d.ts

@@ -0,0 +1 @@
+export { makeCkanApiRequest } from "./request.ts";

package/build/plugins/ckan/ckan/index.js

@@ -0,0 +1,2 @@
+export { makeCkanApiRequest } from "./request.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wbHVnaW5zL2NrYW4vY2thbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxjQUFjLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBtYWtlQ2thbkFwaVJlcXVlc3QgfSBmcm9tIFwiLi9yZXF1ZXN0LnRzXCJcbiJdfQ==

package/build/plugins/ckan/ckan/request.d.ts

@@ -0,0 +1,11 @@
+import type { Descriptor } from "@frictionless-ts/metadata";
+export declare function makeCkanApiRequest<T = Descriptor>(options: {
+    ckanUrl: string;
+    action: string;
+    payload: Descriptor;
+    upload?: {
+        name: string;
+        data: Blob;
+    };
+    apiKey?: string;
+}): Promise<T>;