@frictionless-ts/dataset 1.0.1

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

@@ -0,0 +1,169 @@
+import * as metadataModule from "@frictionless-ts/metadata";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { DescriptorPlugin } from "./plugin.js";
+vi.mock("@frictionless-ts/metadata", async () => {
+    const actual = await vi.importActual("@frictionless-ts/metadata");
+    return {
+        ...actual,
+        loadPackageDescriptor: vi.fn(),
+        savePackageDescriptor: vi.fn(),
+    };
+});
+describe("DescriptorPlugin", () => {
+    let plugin;
+    let mockLoadPackageDescriptor;
+    let mockSavePackageDescriptor;
+    beforeEach(() => {
+        plugin = new DescriptorPlugin();
+        mockLoadPackageDescriptor = vi.mocked(metadataModule.loadPackageDescriptor);
+        mockSavePackageDescriptor = vi.mocked(metadataModule.savePackageDescriptor);
+        vi.clearAllMocks();
+    });
+    describe("loadPackage", () => {
+        it("should load package from local datapackage.json file", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockLoadPackageDescriptor.mockResolvedValue(mockPackage);
+            const result = await plugin.loadPackage("./datapackage.json");
+            expect(mockLoadPackageDescriptor).toHaveBeenCalledWith("./datapackage.json");
+            expect(result).toEqual(mockPackage);
+        });
+        it("should load package from local json file", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockLoadPackageDescriptor.mockResolvedValue(mockPackage);
+            const result = await plugin.loadPackage("./package.json");
+            expect(mockLoadPackageDescriptor).toHaveBeenCalledWith("./package.json");
+            expect(result).toEqual(mockPackage);
+        });
+        it("should return undefined for remote json urls", async () => {
+            const result = await plugin.loadPackage("https://example.com/datapackage.json");
+            expect(mockLoadPackageDescriptor).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for http remote json urls", async () => {
+            const result = await plugin.loadPackage("http://example.com/datapackage.json");
+            expect(mockLoadPackageDescriptor).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for local csv files", async () => {
+            const result = await plugin.loadPackage("./data.csv");
+            expect(mockLoadPackageDescriptor).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for local xlsx files", async () => {
+            const result = await plugin.loadPackage("./data.xlsx");
+            expect(mockLoadPackageDescriptor).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for local parquet files", async () => {
+            const result = await plugin.loadPackage("./data.parquet");
+            expect(mockLoadPackageDescriptor).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should handle absolute paths", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockLoadPackageDescriptor.mockResolvedValue(mockPackage);
+            const result = await plugin.loadPackage("/absolute/path/datapackage.json");
+            expect(mockLoadPackageDescriptor).toHaveBeenCalledWith("/absolute/path/datapackage.json");
+            expect(result).toEqual(mockPackage);
+        });
+        it("should return undefined for github urls", async () => {
+            const result = await plugin.loadPackage("https://github.com/owner/repo/datapackage.json");
+            expect(mockLoadPackageDescriptor).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for zenodo urls", async () => {
+            const result = await plugin.loadPackage("https://zenodo.org/record/123");
+            expect(mockLoadPackageDescriptor).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+    });
+    describe("savePackage", () => {
+        const mockPackage = {
+            name: "test-package",
+            resources: [{ name: "test", data: [] }],
+        };
+        it("should save package to local datapackage.json file", async () => {
+            mockSavePackageDescriptor.mockResolvedValue(undefined);
+            const result = await plugin.savePackage(mockPackage, {
+                target: "./datapackage.json",
+            });
+            expect(mockSavePackageDescriptor).toHaveBeenCalledWith(mockPackage, {
+                path: "./datapackage.json",
+            });
+            expect(result).toEqual({ path: "./datapackage.json" });
+        });
+        it("should save package with absolute path", async () => {
+            mockSavePackageDescriptor.mockResolvedValue(undefined);
+            const result = await plugin.savePackage(mockPackage, {
+                target: "/absolute/path/datapackage.json",
+            });
+            expect(mockSavePackageDescriptor).toHaveBeenCalledWith(mockPackage, {
+                path: "/absolute/path/datapackage.json",
+            });
+            expect(result).toEqual({ path: "/absolute/path/datapackage.json" });
+        });
+        it("should return undefined for remote urls", async () => {
+            const result = await plugin.savePackage(mockPackage, {
+                target: "https://example.com/datapackage.json",
+            });
+            expect(mockSavePackageDescriptor).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for local json files not named datapackage.json", async () => {
+            const result = await plugin.savePackage(mockPackage, {
+                target: "./package.json",
+            });
+            expect(mockSavePackageDescriptor).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for local csv files", async () => {
+            const result = await plugin.savePackage(mockPackage, {
+                target: "./data.csv",
+            });
+            expect(mockSavePackageDescriptor).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for local xlsx files", async () => {
+            const result = await plugin.savePackage(mockPackage, {
+                target: "./data.xlsx",
+            });
+            expect(mockSavePackageDescriptor).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for http urls", async () => {
+            const result = await plugin.savePackage(mockPackage, {
+                target: "http://example.com/datapackage.json",
+            });
+            expect(mockSavePackageDescriptor).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should ignore withRemote option for local files", async () => {
+            mockSavePackageDescriptor.mockResolvedValue(undefined);
+            const result = await plugin.savePackage(mockPackage, {
+                target: "./datapackage.json",
+                withRemote: true,
+            });
+            expect(mockSavePackageDescriptor).toHaveBeenCalledWith(mockPackage, {
+                path: "./datapackage.json",
+            });
+            expect(result).toEqual({ path: "./datapackage.json" });
+        });
+        it("should return undefined for local directories", async () => {
+            const result = await plugin.savePackage(mockPackage, {
+                target: "./data",
+            });
+            expect(mockSavePackageDescriptor).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.spec.js","sourceRoot":"","sources":["../../../plugins/descriptor/plugin.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Package } from \"@frictionless-ts/metadata\"\nimport * as metadataModule from \"@frictionless-ts/metadata\"\nimport { beforeEach, describe, expect, it, vi } from \"vitest\"\nimport { DescriptorPlugin } from \"./plugin.ts\"\n\nvi.mock(\"@frictionless-ts/metadata\", async () => {\n  const actual = await vi.importActual(\"@frictionless-ts/metadata\")\n  return {\n    ...actual,\n    loadPackageDescriptor: vi.fn(),\n    savePackageDescriptor: vi.fn(),\n  }\n})\n\ndescribe(\"DescriptorPlugin\", () => {\n  let plugin: DescriptorPlugin\n  let mockLoadPackageDescriptor: ReturnType<typeof vi.fn>\n  let mockSavePackageDescriptor: ReturnType<typeof vi.fn>\n\n  beforeEach(() => {\n    plugin = new DescriptorPlugin()\n    mockLoadPackageDescriptor = vi.mocked(metadataModule.loadPackageDescriptor)\n    mockSavePackageDescriptor = vi.mocked(metadataModule.savePackageDescriptor)\n    vi.clearAllMocks()\n  })\n\n  describe(\"loadPackage\", () => {\n    it(\"should load package from local datapackage.json file\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      mockLoadPackageDescriptor.mockResolvedValue(mockPackage)\n\n      const result = await plugin.loadPackage(\"./datapackage.json\")\n\n      expect(mockLoadPackageDescriptor).toHaveBeenCalledWith(\n        \"./datapackage.json\",\n      )\n      expect(result).toEqual(mockPackage)\n    })\n\n    it(\"should load package from local json file\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      mockLoadPackageDescriptor.mockResolvedValue(mockPackage)\n\n      const result = await plugin.loadPackage(\"./package.json\")\n\n      expect(mockLoadPackageDescriptor).toHaveBeenCalledWith(\"./package.json\")\n      expect(result).toEqual(mockPackage)\n    })\n\n    it(\"should return undefined for remote json urls\", async () => {\n      const result = await plugin.loadPackage(\n        \"https://example.com/datapackage.json\",\n      )\n\n      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for http remote json urls\", async () => {\n      const result = await plugin.loadPackage(\n        \"http://example.com/datapackage.json\",\n      )\n\n      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for local csv files\", async () => {\n      const result = await plugin.loadPackage(\"./data.csv\")\n\n      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for local xlsx files\", async () => {\n      const result = await plugin.loadPackage(\"./data.xlsx\")\n\n      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for local parquet files\", async () => {\n      const result = await plugin.loadPackage(\"./data.parquet\")\n\n      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should handle absolute paths\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      mockLoadPackageDescriptor.mockResolvedValue(mockPackage)\n\n      const result = await plugin.loadPackage(\"/absolute/path/datapackage.json\")\n\n      expect(mockLoadPackageDescriptor).toHaveBeenCalledWith(\n        \"/absolute/path/datapackage.json\",\n      )\n      expect(result).toEqual(mockPackage)\n    })\n\n    it(\"should return undefined for github urls\", async () => {\n      const result = await plugin.loadPackage(\n        \"https://github.com/owner/repo/datapackage.json\",\n      )\n\n      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for zenodo urls\", async () => {\n      const result = await plugin.loadPackage(\"https://zenodo.org/record/123\")\n\n      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n  })\n\n  describe(\"savePackage\", () => {\n    const mockPackage: Package = {\n      name: \"test-package\",\n      resources: [{ name: \"test\", data: [] }],\n    }\n\n    it(\"should save package to local datapackage.json file\", async () => {\n      mockSavePackageDescriptor.mockResolvedValue(undefined)\n\n      const result = await plugin.savePackage(mockPackage, {\n        target: \"./datapackage.json\",\n      })\n\n      expect(mockSavePackageDescriptor).toHaveBeenCalledWith(mockPackage, {\n        path: \"./datapackage.json\",\n      })\n      expect(result).toEqual({ path: \"./datapackage.json\" })\n    })\n\n    it(\"should save package with absolute path\", async () => {\n      mockSavePackageDescriptor.mockResolvedValue(undefined)\n\n      const result = await plugin.savePackage(mockPackage, {\n        target: \"/absolute/path/datapackage.json\",\n      })\n\n      expect(mockSavePackageDescriptor).toHaveBeenCalledWith(mockPackage, {\n        path: \"/absolute/path/datapackage.json\",\n      })\n      expect(result).toEqual({ path: \"/absolute/path/datapackage.json\" })\n    })\n\n    it(\"should return undefined for remote urls\", async () => {\n      const result = await plugin.savePackage(mockPackage, {\n        target: \"https://example.com/datapackage.json\",\n      })\n\n      expect(mockSavePackageDescriptor).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for local json files not named datapackage.json\", async () => {\n      const result = await plugin.savePackage(mockPackage, {\n        target: \"./package.json\",\n      })\n\n      expect(mockSavePackageDescriptor).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for local csv files\", async () => {\n      const result = await plugin.savePackage(mockPackage, {\n        target: \"./data.csv\",\n      })\n\n      expect(mockSavePackageDescriptor).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for local xlsx files\", async () => {\n      const result = await plugin.savePackage(mockPackage, {\n        target: \"./data.xlsx\",\n      })\n\n      expect(mockSavePackageDescriptor).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for http urls\", async () => {\n      const result = await plugin.savePackage(mockPackage, {\n        target: \"http://example.com/datapackage.json\",\n      })\n\n      expect(mockSavePackageDescriptor).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should ignore withRemote option for local files\", async () => {\n      mockSavePackageDescriptor.mockResolvedValue(undefined)\n\n      const result = await plugin.savePackage(mockPackage, {\n        target: \"./datapackage.json\",\n        withRemote: true,\n      })\n\n      expect(mockSavePackageDescriptor).toHaveBeenCalledWith(mockPackage, {\n        path: \"./datapackage.json\",\n      })\n      expect(result).toEqual({ path: \"./datapackage.json\" })\n    })\n\n    it(\"should return undefined for local directories\", async () => {\n      const result = await plugin.savePackage(mockPackage, {\n        target: \"./data\",\n      })\n\n      expect(mockSavePackageDescriptor).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n  })\n})\n"]}

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

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

package/build/plugins/folder/index.js

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

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

@@ -0,0 +1,2 @@
+export { loadPackageFromFolder } from "./load.ts";
+export { savePackageToFolder } from "./save.ts";

package/build/plugins/folder/package/index.js

@@ -0,0 +1,3 @@
+export { loadPackageFromFolder } from "./load.js";
+export { savePackageToFolder } from "./save.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wbHVnaW5zL2ZvbGRlci9wYWNrYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUNqRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxXQUFXLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBsb2FkUGFja2FnZUZyb21Gb2xkZXIgfSBmcm9tIFwiLi9sb2FkLnRzXCJcbmV4cG9ydCB7IHNhdmVQYWNrYWdlVG9Gb2xkZXIgfSBmcm9tIFwiLi9zYXZlLnRzXCJcbiJdfQ==

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

@@ -0,0 +1 @@
+export declare function loadPackageFromFolder(folderPath: string): Promise<import("@frictionless-ts/metadata").Package>;

package/build/plugins/folder/package/load.js

@@ -0,0 +1,6 @@
+import { join } from "node:path";
+import { loadPackageDescriptor } from "@frictionless-ts/metadata";
+export async function loadPackageFromFolder(folderPath) {
+    return loadPackageDescriptor(join(folderPath, "datapackage.json"));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BsdWdpbnMvZm9sZGVyL3BhY2thZ2UvbG9hZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ2hDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFBO0FBRWpFLE1BQU0sQ0FBQyxLQUFLLFVBQVUscUJBQXFCLENBQUMsVUFBa0I7SUFDNUQsT0FBTyxxQkFBcUIsQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLGtCQUFrQixDQUFDLENBQUMsQ0FBQTtBQUNwRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgam9pbiB9IGZyb20gXCJub2RlOnBhdGhcIlxuaW1wb3J0IHsgbG9hZFBhY2thZ2VEZXNjcmlwdG9yIH0gZnJvbSBcIkBmcmljdGlvbmxlc3MtdHMvbWV0YWRhdGFcIlxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gbG9hZFBhY2thZ2VGcm9tRm9sZGVyKGZvbGRlclBhdGg6IHN0cmluZykge1xuICByZXR1cm4gbG9hZFBhY2thZ2VEZXNjcmlwdG9yKGpvaW4oZm9sZGVyUGF0aCwgXCJkYXRhcGFja2FnZS5qc29uXCIpKVxufVxuIl19

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

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

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

@@ -0,0 +1,175 @@
+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("loadPackageFromFolder", () => {
+    let tempFolderPath;
+    beforeEach(() => {
+        tempFolderPath = getTempFilePath();
+    });
+    it("should load a basic package from folder", async () => {
+        const originalPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "empty-resource",
+                    data: [],
+                },
+            ],
+        };
+        await savePackageToFolder(originalPackage, { folderPath: tempFolderPath });
+        const loadedPackage = await loadPackageFromFolder(tempFolderPath);
+        expect(loadedPackage).toBeDefined();
+        expect(loadedPackage.name).toBe("test-package");
+        expect(loadedPackage.resources).toHaveLength(1);
+    });
+    it("should load package with metadata", async () => {
+        const originalPackage = {
+            name: "test-package",
+            title: "Test Package",
+            description: "A test data package",
+            version: "1.0.0",
+            resources: [
+                {
+                    name: "test-resource",
+                    data: [],
+                },
+            ],
+        };
+        await savePackageToFolder(originalPackage, { folderPath: tempFolderPath });
+        const loadedPackage = await loadPackageFromFolder(tempFolderPath);
+        expect(loadedPackage.name).toBe("test-package");
+        expect(loadedPackage.title).toBe("Test Package");
+        expect(loadedPackage.description).toBe("A test data package");
+        expect(loadedPackage.version).toBe("1.0.0");
+    });
+    it("should load package with inline data resources", async () => {
+        const originalPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    data: [
+                        { id: 1, name: "alice" },
+                        { id: 2, name: "bob" },
+                    ],
+                },
+            ],
+        };
+        await savePackageToFolder(originalPackage, { folderPath: tempFolderPath });
+        const loadedPackage = await loadPackageFromFolder(tempFolderPath);
+        expect(loadedPackage).toBeDefined();
+        expect(loadedPackage.resources).toHaveLength(1);
+        expect(loadedPackage.resources[0]?.name).toBe("test-resource");
+        expect(loadedPackage.resources[0]?.data).toEqual([
+            { id: 1, name: "alice" },
+            { id: 2, name: "bob" },
+        ]);
+    });
+    it("should load 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 loadedPackage = await loadPackageFromFolder(tempFolderPath);
+        expect(loadedPackage).toBeDefined();
+        expect(loadedPackage.resources).toHaveLength(1);
+        expect(loadedPackage.resources[0]?.name).toBe("test-resource");
+        expect(loadedPackage.resources[0]?.format).toBe("csv");
+    });
+    it("should load 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 loadedPackage = await loadPackageFromFolder(tempFolderPath);
+        expect(loadedPackage.resources[0]?.schema).toBeDefined();
+        const schema = loadedPackage.resources[0]?.schema;
+        expect(typeof schema === "object" && "fields" in schema).toBe(true);
+        if (typeof schema === "object" && "fields" in schema) {
+            expect(schema.fields).toHaveLength(2);
+        }
+    });
+    it("should load package with multiple resources", async () => {
+        const csvContent = "id,name\n1,alice\n2,bob";
+        const csvPath = await writeTempFile(csvContent);
+        const originalPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "resource-1",
+                    path: csvPath,
+                    format: "csv",
+                },
+                {
+                    name: "resource-2",
+                    data: [{ id: 1, value: 100 }],
+                },
+            ],
+        };
+        await savePackageToFolder(originalPackage, { folderPath: tempFolderPath });
+        const loadedPackage = await loadPackageFromFolder(tempFolderPath);
+        expect(loadedPackage).toBeDefined();
+        expect(loadedPackage.name).toBe("test-package");
+        expect(loadedPackage.resources).toHaveLength(2);
+        expect(loadedPackage.resources[0]?.name).toBe("resource-1");
+        expect(loadedPackage.resources[1]?.name).toBe("resource-2");
+    });
+    it("should load package with dialect", 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",
+                    dialect: {
+                        delimiter: ";",
+                    },
+                },
+            ],
+        };
+        await savePackageToFolder(originalPackage, { folderPath: tempFolderPath });
+        const loadedPackage = await loadPackageFromFolder(tempFolderPath);
+        expect(loadedPackage.resources[0]?.dialect).toBeDefined();
+        const dialect = loadedPackage.resources[0]?.dialect;
+        expect(typeof dialect === "object" && "delimiter" in dialect).toBe(true);
+        if (typeof dialect === "object" && "delimiter" in dialect) {
+            expect(dialect.delimiter).toBe(";");
+        }
+    });
+    it("should throw error for non-existent folder", async () => {
+        const nonExistentPath = "/non/existent/folder";
+        await expect(loadPackageFromFolder(nonExistentPath)).rejects.toThrow();
+    });
+    it("should throw error for folder without datapackage.json", async () => {
+        const emptyFolderPath = getTempFilePath();
+        const fs = await import("node:fs/promises");
+        await fs.mkdir(emptyFolderPath, { recursive: true });
+        await expect(loadPackageFromFolder(emptyFolderPath)).rejects.toThrow();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load.spec.js","sourceRoot":"","sources":["../../../../plugins/folder/package/load.spec.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AACzD,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AACvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAA;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AAE/C,QAAQ,CAAC,uBAAuB,EAAE,GAAG,EAAE;IACrC,IAAI,cAAsB,CAAA;IAE1B,UAAU,CAAC,GAAG,EAAE;QACd,cAAc,GAAG,eAAe,EAAE,CAAA;IACpC,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,yCAAyC,EAAE,KAAK,IAAI,EAAE;QACvD,MAAM,eAAe,GAAY;YAC/B,IAAI,EAAE,cAAc;YACpB,SAAS,EAAE;gBACT;oBACE,IAAI,EAAE,gBAAgB;oBACtB,IAAI,EAAE,EAAE;iBACT;aACF;SACF,CAAA;QAED,MAAM,mBAAmB,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC,CAAA;QAC1E,MAAM,aAAa,GAAG,MAAM,qBAAqB,CAAC,cAAc,CAAC,CAAA;QAEjE,MAAM,CAAC,aAAa,CAAC,CAAC,WAAW,EAAE,CAAA;QACnC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;QAC/C,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAA;IACjD,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,mCAAmC,EAAE,KAAK,IAAI,EAAE;QACjD,MAAM,eAAe,GAAY;YAC/B,IAAI,EAAE,cAAc;YACpB,KAAK,EAAE,cAAc;YACrB,WAAW,EAAE,qBAAqB;YAClC,OAAO,EAAE,OAAO;YAChB,SAAS,EAAE;gBACT;oBACE,IAAI,EAAE,eAAe;oBACrB,IAAI,EAAE,EAAE;iBACT;aACF;SACF,CAAA;QAED,MAAM,mBAAmB,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC,CAAA;QAC1E,MAAM,aAAa,GAAG,MAAM,qBAAqB,CAAC,cAAc,CAAC,CAAA;QAEjE,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;QAC/C,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;QAChD,MAAM,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAA;QAC7D,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IAC7C,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,gDAAgD,EAAE,KAAK,IAAI,EAAE;QAC9D,MAAM,eAAe,GAAY;YAC/B,IAAI,EAAE,cAAc;YACpB,SAAS,EAAE;gBACT;oBACE,IAAI,EAAE,eAAe;oBACrB,IAAI,EAAE;wBACJ,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;wBACxB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE;qBACvB;iBACF;aACF;SACF,CAAA;QAED,MAAM,mBAAmB,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC,CAAA;QAC1E,MAAM,aAAa,GAAG,MAAM,qBAAqB,CAAC,cAAc,CAAC,CAAA;QAEjE,MAAM,CAAC,aAAa,CAAC,CAAC,WAAW,EAAE,CAAA;QACnC,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAA;QAC/C,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAA;QAC9D,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC;YAC/C,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;YACxB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE;SACvB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,yCAAyC,EAAE,KAAK,IAAI,EAAE;QACvD,MAAM,UAAU,GAAG,yBAAyB,CAAA;QAC5C,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,UAAU,CAAC,CAAA;QAE/C,MAAM,eAAe,GAAY;YAC/B,IAAI,EAAE,cAAc;YACpB,SAAS,EAAE;gBACT;oBACE,IAAI,EAAE,eAAe;oBACrB,IAAI,EAAE,OAAO;oBACb,MAAM,EAAE,KAAK;iBACd;aACF;SACF,CAAA;QAED,MAAM,mBAAmB,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC,CAAA;QAC1E,MAAM,aAAa,GAAG,MAAM,qBAAqB,CAAC,cAAc,CAAC,CAAA;QAEjE,MAAM,CAAC,aAAa,CAAC,CAAC,WAAW,EAAE,CAAA;QACnC,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAA;QAC/C,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAA;QAC9D,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACxD,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,iCAAiC,EAAE,KAAK,IAAI,EAAE;QAC/C,MAAM,eAAe,GAAY;YAC/B,IAAI,EAAE,cAAc;YACpB,SAAS,EAAE;gBACT;oBACE,IAAI,EAAE,eAAe;oBACrB,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;oBAChC,MAAM,EAAE;wBACN,MAAM,EAAE;4BACN,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE;4BAC/B,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE;yBACjC;qBACF;iBACF;aACF;SACF,CAAA;QAED,MAAM,mBAAmB,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC,CAAA;QAC1E,MAAM,aAAa,GAAG,MAAM,qBAAqB,CAAC,cAAc,CAAC,CAAA;QAEjE,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,WAAW,EAAE,CAAA;QACxD,MAAM,MAAM,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,CAAA;QACjD,MAAM,CAAC,OAAO,MAAM,KAAK,QAAQ,IAAI,QAAQ,IAAI,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACnE,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,QAAQ,IAAI,MAAM,EAAE,CAAC;YACrD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAA;QACvC,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,6CAA6C,EAAE,KAAK,IAAI,EAAE;QAC3D,MAAM,UAAU,GAAG,yBAAyB,CAAA;QAC5C,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,UAAU,CAAC,CAAA;QAE/C,MAAM,eAAe,GAAY;YAC/B,IAAI,EAAE,cAAc;YACpB,SAAS,EAAE;gBACT;oBACE,IAAI,EAAE,YAAY;oBAClB,IAAI,EAAE,OAAO;oBACb,MAAM,EAAE,KAAK;iBACd;gBACD;oBACE,IAAI,EAAE,YAAY;oBAClB,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;iBAC9B;aACF;SACF,CAAA;QAED,MAAM,mBAAmB,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC,CAAA;QAC1E,MAAM,aAAa,GAAG,MAAM,qBAAqB,CAAC,cAAc,CAAC,CAAA;QAEjE,MAAM,CAAC,aAAa,CAAC,CAAC,WAAW,EAAE,CAAA;QACnC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;QAC/C,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAA;QAC/C,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;QAC3D,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;IAC7D,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,kCAAkC,EAAE,KAAK,IAAI,EAAE;QAChD,MAAM,UAAU,GAAG,yBAAyB,CAAA;QAC5C,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,UAAU,CAAC,CAAA;QAE/C,MAAM,eAAe,GAAY;YAC/B,IAAI,EAAE,cAAc;YACpB,SAAS,EAAE;gBACT;oBACE,IAAI,EAAE,eAAe;oBACrB,IAAI,EAAE,OAAO;oBACb,MAAM,EAAE,KAAK;oBACb,OAAO,EAAE;wBACP,SAAS,EAAE,GAAG;qBACf;iBACF;aACF;SACF,CAAA;QAED,MAAM,mBAAmB,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC,CAAA;QAC1E,MAAM,aAAa,GAAG,MAAM,qBAAqB,CAAC,cAAc,CAAC,CAAA;QAEjE,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,WAAW,EAAE,CAAA;QACzD,MAAM,OAAO,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,CAAA;QACnD,MAAM,CAAC,OAAO,OAAO,KAAK,QAAQ,IAAI,WAAW,IAAI,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACxE,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,WAAW,IAAI,OAAO,EAAE,CAAC;YAC1D,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QACrC,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,4CAA4C,EAAE,KAAK,IAAI,EAAE;QAC1D,MAAM,eAAe,GAAG,sBAAsB,CAAA;QAE9C,MAAM,MAAM,CAAC,qBAAqB,CAAC,eAAe,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAA;IACxE,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,wDAAwD,EAAE,KAAK,IAAI,EAAE;QACtE,MAAM,eAAe,GAAG,eAAe,EAAE,CAAA;QACzC,MAAM,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAA;QAC3C,MAAM,EAAE,CAAC,KAAK,CAAC,eAAe,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;QAEpD,MAAM,MAAM,CAAC,qBAAqB,CAAC,eAAe,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAA;IACxE,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA","sourcesContent":["import 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(\"loadPackageFromFolder\", () => {\n  let tempFolderPath: string\n\n  beforeEach(() => {\n    tempFolderPath = getTempFilePath()\n  })\n\n  it(\"should load a basic package from folder\", async () => {\n    const originalPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"empty-resource\",\n          data: [],\n        },\n      ],\n    }\n\n    await savePackageToFolder(originalPackage, { folderPath: tempFolderPath })\n    const loadedPackage = await loadPackageFromFolder(tempFolderPath)\n\n    expect(loadedPackage).toBeDefined()\n    expect(loadedPackage.name).toBe(\"test-package\")\n    expect(loadedPackage.resources).toHaveLength(1)\n  })\n\n  it(\"should load package with metadata\", async () => {\n    const originalPackage: Package = {\n      name: \"test-package\",\n      title: \"Test Package\",\n      description: \"A test data package\",\n      version: \"1.0.0\",\n      resources: [\n        {\n          name: \"test-resource\",\n          data: [],\n        },\n      ],\n    }\n\n    await savePackageToFolder(originalPackage, { folderPath: tempFolderPath })\n    const loadedPackage = await loadPackageFromFolder(tempFolderPath)\n\n    expect(loadedPackage.name).toBe(\"test-package\")\n    expect(loadedPackage.title).toBe(\"Test Package\")\n    expect(loadedPackage.description).toBe(\"A test data package\")\n    expect(loadedPackage.version).toBe(\"1.0.0\")\n  })\n\n  it(\"should load package with inline data resources\", async () => {\n    const originalPackage: 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(originalPackage, { folderPath: tempFolderPath })\n    const loadedPackage = await loadPackageFromFolder(tempFolderPath)\n\n    expect(loadedPackage).toBeDefined()\n    expect(loadedPackage.resources).toHaveLength(1)\n    expect(loadedPackage.resources[0]?.name).toBe(\"test-resource\")\n    expect(loadedPackage.resources[0]?.data).toEqual([\n      { id: 1, name: \"alice\" },\n      { id: 2, name: \"bob\" },\n    ])\n  })\n\n  it(\"should load 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 loadedPackage = await loadPackageFromFolder(tempFolderPath)\n\n    expect(loadedPackage).toBeDefined()\n    expect(loadedPackage.resources).toHaveLength(1)\n    expect(loadedPackage.resources[0]?.name).toBe(\"test-resource\")\n    expect(loadedPackage.resources[0]?.format).toBe(\"csv\")\n  })\n\n  it(\"should load 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 loadedPackage = await loadPackageFromFolder(tempFolderPath)\n\n    expect(loadedPackage.resources[0]?.schema).toBeDefined()\n    const schema = loadedPackage.resources[0]?.schema\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    }\n  })\n\n  it(\"should load package with multiple 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: \"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(originalPackage, { folderPath: tempFolderPath })\n    const loadedPackage = await loadPackageFromFolder(tempFolderPath)\n\n    expect(loadedPackage).toBeDefined()\n    expect(loadedPackage.name).toBe(\"test-package\")\n    expect(loadedPackage.resources).toHaveLength(2)\n    expect(loadedPackage.resources[0]?.name).toBe(\"resource-1\")\n    expect(loadedPackage.resources[1]?.name).toBe(\"resource-2\")\n  })\n\n  it(\"should load package with dialect\", 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          dialect: {\n            delimiter: \";\",\n          },\n        },\n      ],\n    }\n\n    await savePackageToFolder(originalPackage, { folderPath: tempFolderPath })\n    const loadedPackage = await loadPackageFromFolder(tempFolderPath)\n\n    expect(loadedPackage.resources[0]?.dialect).toBeDefined()\n    const dialect = loadedPackage.resources[0]?.dialect\n    expect(typeof dialect === \"object\" && \"delimiter\" in dialect).toBe(true)\n    if (typeof dialect === \"object\" && \"delimiter\" in dialect) {\n      expect(dialect.delimiter).toBe(\";\")\n    }\n  })\n\n  it(\"should throw error for non-existent folder\", async () => {\n    const nonExistentPath = \"/non/existent/folder\"\n\n    await expect(loadPackageFromFolder(nonExistentPath)).rejects.toThrow()\n  })\n\n  it(\"should throw error for folder without datapackage.json\", async () => {\n    const emptyFolderPath = getTempFilePath()\n    const fs = await import(\"node:fs/promises\")\n    await fs.mkdir(emptyFolderPath, { recursive: true })\n\n    await expect(loadPackageFromFolder(emptyFolderPath)).rejects.toThrow()\n  })\n})\n"]}

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

@@ -0,0 +1,7 @@
+import type { Descriptor, Package } from "@frictionless-ts/metadata";
+export declare function savePackageToFolder(dataPackage: Package, options: {
+    folderPath: string;
+    withRemote?: boolean;
+}): Promise<{
+    resources: Descriptor[];
+}>;

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

@@ -0,0 +1,35 @@
+import { join } from "node:path";
+import { convertPackageToDescriptor, saveDescriptor, } from "@frictionless-ts/metadata";
+import { assertLocalPathVacant, copyFile } from "../../../file/index.js";
+import { createFolder } from "../../../folder/index.js";
+import { getPackageBasepath } from "../../../package/index.js";
+import { saveResourceFiles } from "../../../resource/index.js";
+export async function savePackageToFolder(dataPackage, options) {
+    const basepath = getPackageBasepath(dataPackage);
+    const { folderPath, withRemote } = options;
+    await assertLocalPathVacant(folderPath);
+    await createFolder(folderPath);
+    const resourceDescriptors = [];
+    for (const resource of dataPackage.resources) {
+        resourceDescriptors.push(await saveResourceFiles(resource, {
+            basepath,
+            withRemote,
+            saveFile: async (options) => {
+                await copyFile({
+                    sourcePath: options.normalizedPath,
+                    targetPath: join(folderPath, options.denormalizedPath),
+                });
+                return options.denormalizedPath;
+            },
+        }));
+    }
+    const descriptor = {
+        ...convertPackageToDescriptor(dataPackage, { basepath }),
+        resources: resourceDescriptors,
+    };
+    await saveDescriptor(descriptor, {
+        path: join(folderPath, "datapackage.json"),
+    });
+    return descriptor;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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