@frictionless-ts/dataset 1.0.1

package/build/plugins/folder/package/save.spec.js

@@ -0,0 +1,328 @@
+import { access, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { beforeEach, describe, expect, it } from "vitest";
+import { getTempFilePath, writeTempFile } from "../../../file/index.js";
+import { loadPackageFromFolder } from "./load.js";
+import { savePackageToFolder } from "./save.js";
+describe("savePackageToFolder", () => {
+    let tempFolderPath;
+    beforeEach(() => {
+        tempFolderPath = getTempFilePath();
+    });
+    it("should save a basic package to folder", async () => {
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    data: [],
+                },
+            ],
+        };
+        await savePackageToFolder(dataPackage, { folderPath: tempFolderPath });
+        const descriptorPath = join(tempFolderPath, "datapackage.json");
+        await expect(access(descriptorPath)).resolves.toBeUndefined();
+    });
+    it("should save package with metadata", async () => {
+        const dataPackage = {
+            name: "test-package",
+            title: "Test Package",
+            description: "A test package",
+            version: "1.0.0",
+            resources: [
+                {
+                    name: "test-resource",
+                    data: [],
+                },
+            ],
+        };
+        await savePackageToFolder(dataPackage, { folderPath: tempFolderPath });
+        const descriptorPath = join(tempFolderPath, "datapackage.json");
+        await expect(access(descriptorPath)).resolves.toBeUndefined();
+    });
+    it("should save package with inline data resources", async () => {
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    data: [
+                        { id: 1, name: "alice" },
+                        { id: 2, name: "bob" },
+                    ],
+                },
+            ],
+        };
+        await savePackageToFolder(dataPackage, { folderPath: tempFolderPath });
+        const descriptorPath = join(tempFolderPath, "datapackage.json");
+        await expect(access(descriptorPath)).resolves.toBeUndefined();
+    });
+    it("should save package with file resources", async () => {
+        const csvContent = "id,name\n1,alice\n2,bob";
+        const csvPath = await writeTempFile(csvContent);
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    path: csvPath,
+                    format: "csv",
+                },
+            ],
+        };
+        await savePackageToFolder(dataPackage, { folderPath: tempFolderPath });
+        const descriptorPath = join(tempFolderPath, "datapackage.json");
+        await expect(access(descriptorPath)).resolves.toBeUndefined();
+    });
+    it("should save package with multiple resources", async () => {
+        const csvContent = "id,name\n1,alice\n2,bob";
+        const csvPath = await writeTempFile(csvContent);
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "resource-1",
+                    path: csvPath,
+                    format: "csv",
+                },
+                {
+                    name: "resource-2",
+                    data: [{ id: 1, value: 100 }],
+                },
+            ],
+        };
+        await savePackageToFolder(dataPackage, { folderPath: tempFolderPath });
+        const descriptorPath = join(tempFolderPath, "datapackage.json");
+        await expect(access(descriptorPath)).resolves.toBeUndefined();
+    });
+    it("should save package with schema", async () => {
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    data: [{ id: 1, name: "alice" }],
+                    schema: {
+                        fields: [
+                            { name: "id", type: "integer" },
+                            { name: "name", type: "string" },
+                        ],
+                    },
+                },
+            ],
+        };
+        await savePackageToFolder(dataPackage, { folderPath: tempFolderPath });
+        const descriptorPath = join(tempFolderPath, "datapackage.json");
+        await expect(access(descriptorPath)).resolves.toBeUndefined();
+    });
+    it("should save package with dialect", async () => {
+        const csvContent = "id;name\n1;alice\n2;bob";
+        const csvPath = await writeTempFile(csvContent);
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    path: csvPath,
+                    format: "csv",
+                    dialect: {
+                        delimiter: ";",
+                    },
+                },
+            ],
+        };
+        await savePackageToFolder(dataPackage, { folderPath: tempFolderPath });
+        const descriptorPath = join(tempFolderPath, "datapackage.json");
+        await expect(access(descriptorPath)).resolves.toBeUndefined();
+    });
+    it("should save and reload package with same structure", async () => {
+        const originalPackage = {
+            name: "test-package",
+            title: "Test Package",
+            description: "A test package",
+            resources: [
+                {
+                    name: "test-resource",
+                    data: [{ id: 1, name: "alice" }],
+                },
+            ],
+        };
+        await savePackageToFolder(originalPackage, { folderPath: tempFolderPath });
+        const reloadedPackage = await loadPackageFromFolder(tempFolderPath);
+        expect(reloadedPackage).toBeDefined();
+        expect(reloadedPackage.name).toBe("test-package");
+        expect(reloadedPackage.title).toBe("Test Package");
+        expect(reloadedPackage.description).toBe("A test package");
+        expect(reloadedPackage.resources).toHaveLength(1);
+        expect(reloadedPackage.resources[0]?.name).toBe("test-resource");
+    });
+    it("should save and reload package preserving metadata", async () => {
+        const originalPackage = {
+            name: "test-package",
+            title: "Test Package",
+            description: "A test package",
+            version: "1.0.0",
+            keywords: ["test", "package"],
+            resources: [
+                {
+                    name: "test-resource",
+                    data: [{ id: 1 }],
+                },
+            ],
+        };
+        await savePackageToFolder(originalPackage, { folderPath: tempFolderPath });
+        const reloadedPackage = await loadPackageFromFolder(tempFolderPath);
+        expect(reloadedPackage.name).toBe("test-package");
+        expect(reloadedPackage.title).toBe("Test Package");
+        expect(reloadedPackage.version).toBe("1.0.0");
+        expect(reloadedPackage.keywords).toEqual(["test", "package"]);
+    });
+    it("should save and reload package with schema", async () => {
+        const originalPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    data: [{ id: 1, name: "alice" }],
+                    schema: {
+                        fields: [
+                            { name: "id", type: "integer" },
+                            { name: "name", type: "string" },
+                        ],
+                    },
+                },
+            ],
+        };
+        await savePackageToFolder(originalPackage, { folderPath: tempFolderPath });
+        const reloadedPackage = await loadPackageFromFolder(tempFolderPath);
+        const schema = reloadedPackage.resources[0]?.schema;
+        expect(schema).toBeDefined();
+        expect(typeof schema === "object" && "fields" in schema).toBe(true);
+        if (typeof schema === "object" && "fields" in schema) {
+            expect(schema.fields).toHaveLength(2);
+            expect(schema.fields?.[0]?.name).toBe("id");
+            expect(schema.fields?.[1]?.name).toBe("name");
+        }
+    });
+    it("should save and reload package with file resources", async () => {
+        const csvContent = "id,name\n1,alice\n2,bob";
+        const csvPath = await writeTempFile(csvContent);
+        const originalPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    path: csvPath,
+                    format: "csv",
+                },
+            ],
+        };
+        await savePackageToFolder(originalPackage, { folderPath: tempFolderPath });
+        const reloadedPackage = await loadPackageFromFolder(tempFolderPath);
+        expect(reloadedPackage.resources).toHaveLength(1);
+        expect(reloadedPackage.resources[0]?.name).toBe("test-resource");
+        expect(reloadedPackage.resources[0]?.format).toBe("csv");
+    });
+    it("should throw error when saving to existing folder", async () => {
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    data: [],
+                },
+            ],
+        };
+        const fs = await import("node:fs/promises");
+        await fs.mkdir(tempFolderPath, { recursive: true });
+        await fs.writeFile(join(tempFolderPath, "existing.txt"), "content");
+        await expect(savePackageToFolder(dataPackage, { folderPath: tempFolderPath })).rejects.toThrow();
+    });
+    it("should create valid folder structure", async () => {
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    data: [{ id: 1 }],
+                },
+            ],
+        };
+        await savePackageToFolder(dataPackage, { folderPath: tempFolderPath });
+        const reloadedPackage = await loadPackageFromFolder(tempFolderPath);
+        expect(reloadedPackage).toMatchObject({
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                },
+            ],
+        });
+    });
+    it("should save package with multiple file resources", async () => {
+        const csv1Content = "id,name\n1,alice";
+        const csv2Content = "id,value\n1,100";
+        const csv1Path = await writeTempFile(csv1Content);
+        const csv2Path = await writeTempFile(csv2Content);
+        const originalPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "resource-1",
+                    path: csv1Path,
+                    format: "csv",
+                },
+                {
+                    name: "resource-2",
+                    path: csv2Path,
+                    format: "csv",
+                },
+            ],
+        };
+        await savePackageToFolder(originalPackage, { folderPath: tempFolderPath });
+        const reloadedPackage = await loadPackageFromFolder(tempFolderPath);
+        expect(reloadedPackage.resources).toHaveLength(2);
+        expect(reloadedPackage.resources[0]?.name).toBe("resource-1");
+        expect(reloadedPackage.resources[1]?.name).toBe("resource-2");
+    });
+    it("should create datapackage.json in folder", async () => {
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    data: [{ id: 1 }],
+                },
+            ],
+        };
+        await savePackageToFolder(dataPackage, { folderPath: tempFolderPath });
+        const descriptorPath = join(tempFolderPath, "datapackage.json");
+        const descriptorContent = await readFile(descriptorPath, "utf-8");
+        const descriptor = JSON.parse(descriptorContent);
+        expect(descriptor.name).toBe("test-package");
+        expect(descriptor.resources).toHaveLength(1);
+    });
+    it("should copy file resources to folder", async () => {
+        const csvContent = "id,name\n1,alice\n2,bob";
+        const csvPath = await writeTempFile(csvContent);
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    path: csvPath,
+                    format: "csv",
+                },
+            ],
+        };
+        await savePackageToFolder(dataPackage, { folderPath: tempFolderPath });
+        const descriptorPath = join(tempFolderPath, "datapackage.json");
+        const descriptorContent = await readFile(descriptorPath, "utf-8");
+        const descriptor = JSON.parse(descriptorContent);
+        const resourcePath = descriptor.resources[0].path;
+        const resourceFilePath = join(tempFolderPath, resourcePath);
+        const resourceContent = await readFile(resourceFilePath, "utf-8");
+        expect(resourceContent).toBe(csvContent);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"save.spec.js","sourceRoot":"","sources":["../../../../plugins/folder/package/save.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { access, readFile } from \"node:fs/promises\"\nimport { join } from \"node:path\"\nimport type { Package } from \"@frictionless-ts/metadata\"\nimport { beforeEach, describe, expect, it } from \"vitest\"\nimport { getTempFilePath, writeTempFile } from \"../../../file/index.ts\"\nimport { loadPackageFromFolder } from \"./load.ts\"\nimport { savePackageToFolder } from \"./save.ts\"\n\ndescribe(\"savePackageToFolder\", () => {\n  let tempFolderPath: string\n\n  beforeEach(() => {\n    tempFolderPath = getTempFilePath()\n  })\n\n  it(\"should save a basic package to folder\", async () => {\n    const dataPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          data: [],\n        },\n      ],\n    }\n\n    await savePackageToFolder(dataPackage, { folderPath: tempFolderPath })\n\n    const descriptorPath = join(tempFolderPath, \"datapackage.json\")\n    await expect(access(descriptorPath)).resolves.toBeUndefined()\n  })\n\n  it(\"should save package with metadata\", async () => {\n    const dataPackage: Package = {\n      name: \"test-package\",\n      title: \"Test Package\",\n      description: \"A test package\",\n      version: \"1.0.0\",\n      resources: [\n        {\n          name: \"test-resource\",\n          data: [],\n        },\n      ],\n    }\n\n    await savePackageToFolder(dataPackage, { folderPath: tempFolderPath })\n\n    const descriptorPath = join(tempFolderPath, \"datapackage.json\")\n    await expect(access(descriptorPath)).resolves.toBeUndefined()\n  })\n\n  it(\"should save package with inline data resources\", async () => {\n    const dataPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          data: [\n            { id: 1, name: \"alice\" },\n            { id: 2, name: \"bob\" },\n          ],\n        },\n      ],\n    }\n\n    await savePackageToFolder(dataPackage, { folderPath: tempFolderPath })\n\n    const descriptorPath = join(tempFolderPath, \"datapackage.json\")\n    await expect(access(descriptorPath)).resolves.toBeUndefined()\n  })\n\n  it(\"should save package with file resources\", async () => {\n    const csvContent = \"id,name\\n1,alice\\n2,bob\"\n    const csvPath = await writeTempFile(csvContent)\n\n    const dataPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          path: csvPath,\n          format: \"csv\",\n        },\n      ],\n    }\n\n    await savePackageToFolder(dataPackage, { folderPath: tempFolderPath })\n\n    const descriptorPath = join(tempFolderPath, \"datapackage.json\")\n    await expect(access(descriptorPath)).resolves.toBeUndefined()\n  })\n\n  it(\"should save package with multiple resources\", async () => {\n    const csvContent = \"id,name\\n1,alice\\n2,bob\"\n    const csvPath = await writeTempFile(csvContent)\n\n    const dataPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"resource-1\",\n          path: csvPath,\n          format: \"csv\",\n        },\n        {\n          name: \"resource-2\",\n          data: [{ id: 1, value: 100 }],\n        },\n      ],\n    }\n\n    await savePackageToFolder(dataPackage, { folderPath: tempFolderPath })\n\n    const descriptorPath = join(tempFolderPath, \"datapackage.json\")\n    await expect(access(descriptorPath)).resolves.toBeUndefined()\n  })\n\n  it(\"should save package with schema\", async () => {\n    const dataPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          data: [{ id: 1, name: \"alice\" }],\n          schema: {\n            fields: [\n              { name: \"id\", type: \"integer\" },\n              { name: \"name\", type: \"string\" },\n            ],\n          },\n        },\n      ],\n    }\n\n    await savePackageToFolder(dataPackage, { folderPath: tempFolderPath })\n\n    const descriptorPath = join(tempFolderPath, \"datapackage.json\")\n    await expect(access(descriptorPath)).resolves.toBeUndefined()\n  })\n\n  it(\"should save package with dialect\", async () => {\n    const csvContent = \"id;name\\n1;alice\\n2;bob\"\n    const csvPath = await writeTempFile(csvContent)\n\n    const dataPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          path: csvPath,\n          format: \"csv\",\n          dialect: {\n            delimiter: \";\",\n          },\n        },\n      ],\n    }\n\n    await savePackageToFolder(dataPackage, { folderPath: tempFolderPath })\n\n    const descriptorPath = join(tempFolderPath, \"datapackage.json\")\n    await expect(access(descriptorPath)).resolves.toBeUndefined()\n  })\n\n  it(\"should save and reload package with same structure\", async () => {\n    const originalPackage: Package = {\n      name: \"test-package\",\n      title: \"Test Package\",\n      description: \"A test package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          data: [{ id: 1, name: \"alice\" }],\n        },\n      ],\n    }\n\n    await savePackageToFolder(originalPackage, { folderPath: tempFolderPath })\n    const reloadedPackage = await loadPackageFromFolder(tempFolderPath)\n\n    expect(reloadedPackage).toBeDefined()\n    expect(reloadedPackage.name).toBe(\"test-package\")\n    expect(reloadedPackage.title).toBe(\"Test Package\")\n    expect(reloadedPackage.description).toBe(\"A test package\")\n    expect(reloadedPackage.resources).toHaveLength(1)\n    expect(reloadedPackage.resources[0]?.name).toBe(\"test-resource\")\n  })\n\n  it(\"should save and reload package preserving metadata\", async () => {\n    const originalPackage: Package = {\n      name: \"test-package\",\n      title: \"Test Package\",\n      description: \"A test package\",\n      version: \"1.0.0\",\n      keywords: [\"test\", \"package\"],\n      resources: [\n        {\n          name: \"test-resource\",\n          data: [{ id: 1 }],\n        },\n      ],\n    }\n\n    await savePackageToFolder(originalPackage, { folderPath: tempFolderPath })\n    const reloadedPackage = await loadPackageFromFolder(tempFolderPath)\n\n    expect(reloadedPackage.name).toBe(\"test-package\")\n    expect(reloadedPackage.title).toBe(\"Test Package\")\n    expect(reloadedPackage.version).toBe(\"1.0.0\")\n    expect(reloadedPackage.keywords).toEqual([\"test\", \"package\"])\n  })\n\n  it(\"should save and reload package with schema\", async () => {\n    const originalPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          data: [{ id: 1, name: \"alice\" }],\n          schema: {\n            fields: [\n              { name: \"id\", type: \"integer\" },\n              { name: \"name\", type: \"string\" },\n            ],\n          },\n        },\n      ],\n    }\n\n    await savePackageToFolder(originalPackage, { folderPath: tempFolderPath })\n    const reloadedPackage = await loadPackageFromFolder(tempFolderPath)\n\n    const schema = reloadedPackage.resources[0]?.schema\n    expect(schema).toBeDefined()\n    expect(typeof schema === \"object\" && \"fields\" in schema).toBe(true)\n    if (typeof schema === \"object\" && \"fields\" in schema) {\n      expect(schema.fields).toHaveLength(2)\n      expect(schema.fields?.[0]?.name).toBe(\"id\")\n      expect(schema.fields?.[1]?.name).toBe(\"name\")\n    }\n  })\n\n  it(\"should save and reload package with file resources\", async () => {\n    const csvContent = \"id,name\\n1,alice\\n2,bob\"\n    const csvPath = await writeTempFile(csvContent)\n\n    const originalPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          path: csvPath,\n          format: \"csv\",\n        },\n      ],\n    }\n\n    await savePackageToFolder(originalPackage, { folderPath: tempFolderPath })\n    const reloadedPackage = await loadPackageFromFolder(tempFolderPath)\n\n    expect(reloadedPackage.resources).toHaveLength(1)\n    expect(reloadedPackage.resources[0]?.name).toBe(\"test-resource\")\n    expect(reloadedPackage.resources[0]?.format).toBe(\"csv\")\n  })\n\n  it(\"should throw error when saving to existing folder\", async () => {\n    const dataPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          data: [],\n        },\n      ],\n    }\n\n    const fs = await import(\"node:fs/promises\")\n    await fs.mkdir(tempFolderPath, { recursive: true })\n    await fs.writeFile(join(tempFolderPath, \"existing.txt\"), \"content\")\n\n    await expect(\n      savePackageToFolder(dataPackage, { folderPath: tempFolderPath }),\n    ).rejects.toThrow()\n  })\n\n  it(\"should create valid folder structure\", async () => {\n    const dataPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          data: [{ id: 1 }],\n        },\n      ],\n    }\n\n    await savePackageToFolder(dataPackage, { folderPath: tempFolderPath })\n    const reloadedPackage = await loadPackageFromFolder(tempFolderPath)\n\n    expect(reloadedPackage).toMatchObject({\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n        },\n      ],\n    })\n  })\n\n  it(\"should save package with multiple file resources\", async () => {\n    const csv1Content = \"id,name\\n1,alice\"\n    const csv2Content = \"id,value\\n1,100\"\n    const csv1Path = await writeTempFile(csv1Content)\n    const csv2Path = await writeTempFile(csv2Content)\n\n    const originalPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"resource-1\",\n          path: csv1Path,\n          format: \"csv\",\n        },\n        {\n          name: \"resource-2\",\n          path: csv2Path,\n          format: \"csv\",\n        },\n      ],\n    }\n\n    await savePackageToFolder(originalPackage, { folderPath: tempFolderPath })\n    const reloadedPackage = await loadPackageFromFolder(tempFolderPath)\n\n    expect(reloadedPackage.resources).toHaveLength(2)\n    expect(reloadedPackage.resources[0]?.name).toBe(\"resource-1\")\n    expect(reloadedPackage.resources[1]?.name).toBe(\"resource-2\")\n  })\n\n  it(\"should create datapackage.json in folder\", async () => {\n    const dataPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          data: [{ id: 1 }],\n        },\n      ],\n    }\n\n    await savePackageToFolder(dataPackage, { folderPath: tempFolderPath })\n\n    const descriptorPath = join(tempFolderPath, \"datapackage.json\")\n    const descriptorContent = await readFile(descriptorPath, \"utf-8\")\n    const descriptor = JSON.parse(descriptorContent)\n\n    expect(descriptor.name).toBe(\"test-package\")\n    expect(descriptor.resources).toHaveLength(1)\n  })\n\n  it(\"should copy file resources to folder\", async () => {\n    const csvContent = \"id,name\\n1,alice\\n2,bob\"\n    const csvPath = await writeTempFile(csvContent)\n\n    const dataPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          path: csvPath,\n          format: \"csv\",\n        },\n      ],\n    }\n\n    await savePackageToFolder(dataPackage, { folderPath: tempFolderPath })\n\n    const descriptorPath = join(tempFolderPath, \"datapackage.json\")\n    const descriptorContent = await readFile(descriptorPath, \"utf-8\")\n    const descriptor = JSON.parse(descriptorContent)\n\n    const resourcePath = descriptor.resources[0].path\n    const resourceFilePath = join(tempFolderPath, resourcePath)\n    const resourceContent = await readFile(resourceFilePath, \"utf-8\")\n\n    expect(resourceContent).toBe(csvContent)\n  })\n})\n"]}

package/build/plugins/folder/plugin.d.ts

@@ -0,0 +1,4 @@
+import type { DatasetPlugin } from "../../plugin.ts";
+export declare class FolderPlugin implements DatasetPlugin {
+    loadPackage(source: string): Promise<import("@frictionless-ts/metadata").Package | undefined>;
+}

package/build/plugins/folder/plugin.js

@@ -0,0 +1,19 @@
+import { stat } from "node:fs/promises";
+import { isRemotePath } from "@frictionless-ts/metadata";
+import { loadPackageFromFolder } from "./package/index.js";
+export class FolderPlugin {
+    async loadPackage(source) {
+        const isFolder = await getIsFolder(source);
+        if (!isFolder)
+            return undefined;
+        const dataPackage = await loadPackageFromFolder(source);
+        return dataPackage;
+    }
+}
+async function getIsFolder(path) {
+    const isRemote = isRemotePath(path);
+    if (isRemote)
+        return false;
+    return (await stat(path)).isDirectory();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGx1Z2lucy9mb2xkZXIvcGx1Z2luLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQTtBQUN2QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sMkJBQTJCLENBQUE7QUFFeEQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sb0JBQW9CLENBQUE7QUFFMUQsTUFBTSxPQUFPLFlBQVk7SUFDdkIsS0FBSyxDQUFDLFdBQVcsQ0FBQyxNQUFjO1FBQzlCLE1BQU0sUUFBUSxHQUFHLE1BQU0sV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFBO1FBQzFDLElBQUksQ0FBQyxRQUFRO1lBQUUsT0FBTyxTQUFTLENBQUE7UUFFL0IsTUFBTSxXQUFXLEdBQUcsTUFBTSxxQkFBcUIsQ0FBQyxNQUFNLENBQUMsQ0FBQTtRQUN2RCxPQUFPLFdBQVcsQ0FBQTtJQUNwQixDQUFDO0NBR0Y7QUFFRCxLQUFLLFVBQVUsV0FBVyxDQUFDLElBQVk7SUFDckMsTUFBTSxRQUFRLEdBQUcsWUFBWSxDQUFDLElBQUksQ0FBQyxDQUFBO0lBQ25DLElBQUksUUFBUTtRQUFFLE9BQU8sS0FBSyxDQUFBO0lBRTFCLE9BQU8sQ0FBQyxNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLFdBQVcsRUFBRSxDQUFBO0FBQ3pDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzdGF0IH0gZnJvbSBcIm5vZGU6ZnMvcHJvbWlzZXNcIlxuaW1wb3J0IHsgaXNSZW1vdGVQYXRoIH0gZnJvbSBcIkBmcmljdGlvbmxlc3MtdHMvbWV0YWRhdGFcIlxuaW1wb3J0IHR5cGUgeyBEYXRhc2V0UGx1Z2luIH0gZnJvbSBcIi4uLy4uL3BsdWdpbi50c1wiXG5pbXBvcnQgeyBsb2FkUGFja2FnZUZyb21Gb2xkZXIgfSBmcm9tIFwiLi9wYWNrYWdlL2luZGV4LnRzXCJcblxuZXhwb3J0IGNsYXNzIEZvbGRlclBsdWdpbiBpbXBsZW1lbnRzIERhdGFzZXRQbHVnaW4ge1xuICBhc3luYyBsb2FkUGFja2FnZShzb3VyY2U6IHN0cmluZykge1xuICAgIGNvbnN0IGlzRm9sZGVyID0gYXdhaXQgZ2V0SXNGb2xkZXIoc291cmNlKVxuICAgIGlmICghaXNGb2xkZXIpIHJldHVybiB1bmRlZmluZWRcblxuICAgIGNvbnN0IGRhdGFQYWNrYWdlID0gYXdhaXQgbG9hZFBhY2thZ2VGcm9tRm9sZGVyKHNvdXJjZSlcbiAgICByZXR1cm4gZGF0YVBhY2thZ2VcbiAgfVxuXG4gIC8vIFRPT0Q6IGltcGxlbWVudCBzYXZlUGFja2FnZT9cbn1cblxuYXN5bmMgZnVuY3Rpb24gZ2V0SXNGb2xkZXIocGF0aDogc3RyaW5nKSB7XG4gIGNvbnN0IGlzUmVtb3RlID0gaXNSZW1vdGVQYXRoKHBhdGgpXG4gIGlmIChpc1JlbW90ZSkgcmV0dXJuIGZhbHNlXG5cbiAgcmV0dXJuIChhd2FpdCBzdGF0KHBhdGgpKS5pc0RpcmVjdG9yeSgpXG59XG4iXX0=

package/build/plugins/folder/plugin.spec.d.ts

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

package/build/plugins/folder/plugin.spec.js

@@ -0,0 +1,53 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as packageModule from "./package/index.js";
+import { FolderPlugin } from "./plugin.js";
+vi.mock("./package/index.ts", () => ({
+    loadPackageFromFolder: vi.fn(),
+}));
+describe("FolderPlugin", () => {
+    let plugin;
+    let mockLoadPackageFromFolder;
+    beforeEach(() => {
+        plugin = new FolderPlugin();
+        mockLoadPackageFromFolder = vi.mocked(packageModule.loadPackageFromFolder);
+        vi.clearAllMocks();
+    });
+    describe("loadPackage", () => {
+        it("should load package from local directory", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockLoadPackageFromFolder.mockResolvedValue(mockPackage);
+            const result = await plugin.loadPackage(".");
+            expect(mockLoadPackageFromFolder).toHaveBeenCalledWith(".");
+            expect(result).toEqual(mockPackage);
+        });
+        it("should return undefined for remote paths", async () => {
+            const result = await plugin.loadPackage("http://example.com/data");
+            expect(mockLoadPackageFromFolder).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for https paths", async () => {
+            const result = await plugin.loadPackage("https://example.com/data");
+            expect(mockLoadPackageFromFolder).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for github urls", async () => {
+            const result = await plugin.loadPackage("https://github.com/owner/repo/data");
+            expect(mockLoadPackageFromFolder).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for ftp paths", async () => {
+            const result = await plugin.loadPackage("ftp://example.com/data");
+            expect(mockLoadPackageFromFolder).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for zenodo urls", async () => {
+            const result = await plugin.loadPackage("https://zenodo.org/record/123");
+            expect(mockLoadPackageFromFolder).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/build/plugins/github/github/index.js

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

package/build/plugins/github/github/path.d.ts

@@ -0,0 +1 @@
+export declare function normalizeFileLink(link: string): string;

package/build/plugins/github/github/path.js

@@ -0,0 +1,4 @@
+export function normalizeFileLink(link) {
+    return link.replace("/api/", "/").replace(/\/content$/, "");
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BsdWdpbnMvZ2l0aHViL2dpdGh1Yi9wYXRoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxpQkFBaUIsQ0FBQyxJQUFZO0lBQzVDLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsR0FBRyxDQUFDLENBQUMsT0FBTyxDQUFDLFlBQVksRUFBRSxFQUFFLENBQUMsQ0FBQTtBQUM3RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIG5vcm1hbGl6ZUZpbGVMaW5rKGxpbms6IHN0cmluZykge1xuICByZXR1cm4gbGluay5yZXBsYWNlKFwiL2FwaS9cIiwgXCIvXCIpLnJlcGxhY2UoL1xcL2NvbnRlbnQkLywgXCJcIilcbn1cbiJdfQ==

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

@@ -0,0 +1,15 @@
+import type { Descriptor } from "@frictionless-ts/metadata";
+/**
+ * Makes a request to the Github API
+ */
+export declare function makeGithubApiRequest<T = Descriptor>(options: {
+    endpoint: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    payload?: Descriptor;
+    apiKey?: string;
+    upload?: {
+        name: string;
+        data: Blob;
+        path?: string;
+    };
+}): Promise<T>;

package/build/plugins/github/github/request.js

@@ -0,0 +1,43 @@
+/**
+ * Makes a request to the Github API
+ */
+export async function makeGithubApiRequest(options) {
+    const { endpoint, method = "GET", payload, upload, apiKey } = options;
+    let body;
+    const headers = {};
+    if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    // Create full API URL
+    const baseUrl = "https://api.github.com";
+    const url = `${baseUrl}${endpoint}`;
+    if (upload) {
+        body = new FormData();
+        body.append("file", upload.data, upload.name);
+        if (payload) {
+            for (const [key, value] of Object.entries(payload)) {
+                if (typeof value === "object" && value !== null) {
+                    body.append(key, JSON.stringify(value));
+                }
+                else {
+                    body.append(key, String(value));
+                }
+            }
+        }
+    }
+    else if (payload) {
+        body = JSON.stringify(payload);
+        headers["Content-Type"] = "application/json";
+    }
+    const response = await fetch(url, {
+        method,
+        headers,
+        body,
+    });
+    if (!response.ok || response.status === 204) {
+        const errorText = await response.text();
+        throw new Error(`Github API error: ${response.status} ${response.statusText}\n${errorText}`);
+    }
+    return (await response.json());
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,3 @@
+export * from "./package/index.ts";
+export * from "./resource/index.ts";
+export * from "./plugin.ts";

package/build/plugins/github/index.js

@@ -0,0 +1,4 @@
+export * from "./package/index.js";
+export * from "./resource/index.js";
+export * from "./plugin.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wbHVnaW5zL2dpdGh1Yi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFBO0FBQ2xDLGNBQWMscUJBQXFCLENBQUE7QUFDbkMsY0FBYyxhQUFhLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9wYWNrYWdlL2luZGV4LnRzXCJcbmV4cG9ydCAqIGZyb20gXCIuL3Jlc291cmNlL2luZGV4LnRzXCJcbmV4cG9ydCAqIGZyb20gXCIuL3BsdWdpbi50c1wiXG4iXX0=

package/build/plugins/github/package/License.d.ts

@@ -0,0 +1,21 @@
+/**
+ * GitHub repository license
+ */
+export interface GithubLicense {
+    /**
+     * License key
+     */
+    key: string;
+    /**
+     * License name
+     */
+    name: string;
+    /**
+     * License SPDX ID
+     */
+    spdx_id: string;
+    /**
+     * License URL
+     */
+    url: string;
+}

package/build/plugins/github/package/License.js

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

package/build/plugins/github/package/Owner.d.ts

@@ -0,0 +1,25 @@
+/**
+ * GitHub repository owner
+ */
+export interface GithubOwner {
+    /**
+     * Owner login name
+     */
+    login: string;
+    /**
+     * Owner ID
+     */
+    id: number;
+    /**
+     * Owner avatar URL
+     */
+    avatar_url: string;
+    /**
+     * Owner URL
+     */
+    html_url: string;
+    /**
+     * Owner type (User/Organization)
+     */
+    type: "User" | "Organization";
+}

package/build/plugins/github/package/Owner.js

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