@frictionless-ts/metadata 1.0.1

package/build/package/save.spec.js

@@ -0,0 +1,311 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { temporaryDirectory } from "tempy";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { savePackageDescriptor } from "./save.js";
+describe("savePackageDescriptor", () => {
+    let testDir;
+    let testPath;
+    let testPackage;
+    beforeEach(() => {
+        testDir = temporaryDirectory();
+        testPath = path.join(testDir, "datapackage.json");
+        testPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    path: path.join(testDir, "data.csv"),
+                },
+            ],
+        };
+    });
+    afterEach(async () => {
+        try {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            if (error instanceof Error && !error.message.includes("ENOENT")) {
+                console.error(`Failed to clean up test directory: ${testDir}`, error);
+            }
+        }
+    });
+    it("should save a package descriptor to a file and maintain its structure", async () => {
+        await savePackageDescriptor(testPackage, { path: testPath });
+        const fileExists = await fs
+            .stat(testPath)
+            .then(() => true)
+            .catch(() => false);
+        expect(fileExists).toBe(true);
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        const { $schema, ...packageWithoutSchema } = parsedContent;
+        expect(packageWithoutSchema.name).toEqual(testPackage.name);
+        expect(packageWithoutSchema.resources).toHaveLength(1);
+        expect(packageWithoutSchema.resources[0].name).toBe("test-resource");
+        expect(packageWithoutSchema.resources[0].path).toBe("data.csv");
+        expect($schema).toBe("https://datapackage.org/profiles/2.0/datapackage.json");
+    });
+    it("should add $schema property if not present", async () => {
+        await savePackageDescriptor(testPackage, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.$schema).toBe("https://datapackage.org/profiles/2.0/datapackage.json");
+    });
+    it("should preserve existing $schema property", async () => {
+        const packageWithSchema = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    path: path.join(testDir, "data.csv"),
+                },
+            ],
+            $schema: "https://custom.schema.url",
+        };
+        await savePackageDescriptor(packageWithSchema, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.$schema).toBe("https://custom.schema.url");
+    });
+    it("should use pretty formatting with 2-space indentation", async () => {
+        await savePackageDescriptor(testPackage, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const lines = content.split("\n");
+        expect(lines.length).toBeGreaterThan(1);
+        if (lines.length > 1 && lines[1]) {
+            expect(lines[1].startsWith("  ")).toBe(true);
+        }
+    });
+    it("should save package with multiple resources", async () => {
+        const packageWithMultipleResources = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "resource1",
+                    path: path.join(testDir, "data1.csv"),
+                },
+                {
+                    name: "resource2",
+                    path: path.join(testDir, "data2.json"),
+                    format: "json",
+                },
+            ],
+        };
+        await savePackageDescriptor(packageWithMultipleResources, {
+            path: testPath,
+        });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.resources).toHaveLength(2);
+        expect(parsedContent.resources[0]?.name).toBe("resource1");
+        expect(parsedContent.resources[1]?.name).toBe("resource2");
+    });
+    it("should save package with resource containing schema", async () => {
+        const packageWithSchema = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    path: path.join(testDir, "data.csv"),
+                    schema: {
+                        fields: [
+                            { name: "id", type: "integer" },
+                            { name: "name", type: "string" },
+                        ],
+                    },
+                },
+            ],
+        };
+        await savePackageDescriptor(packageWithSchema, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.resources[0]?.schema).toEqual(packageWithSchema.resources[0]?.schema);
+    });
+    it("should save package with resource containing dialect", async () => {
+        const packageWithDialect = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    path: path.join(testDir, "data.csv"),
+                    dialect: {
+                        delimiter: ";",
+                        lineTerminator: "\n",
+                    },
+                },
+            ],
+        };
+        await savePackageDescriptor(packageWithDialect, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.resources[0]?.dialect).toEqual(packageWithDialect.resources[0]?.dialect);
+    });
+    it("should save package to a nested directory path", async () => {
+        const nestedPath = path.join(testDir, "nested", "dir", "datapackage.json");
+        const nestedPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    path: path.join(testDir, "nested", "dir", "data.csv"),
+                },
+            ],
+        };
+        await savePackageDescriptor(nestedPackage, { path: nestedPath });
+        const fileExists = await fs
+            .stat(nestedPath)
+            .then(() => true)
+            .catch(() => false);
+        expect(fileExists).toBe(true);
+        const content = await fs.readFile(nestedPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.name).toBe(nestedPackage.name);
+    });
+    it("should throw an error when file exists and overwrite is false", async () => {
+        await savePackageDescriptor(testPackage, { path: testPath });
+        await expect(savePackageDescriptor(testPackage, {
+            path: testPath,
+            overwrite: false,
+        })).rejects.toThrow();
+    });
+    it("should throw an error when file exists and overwrite is not specified", async () => {
+        await savePackageDescriptor(testPackage, { path: testPath });
+        await expect(savePackageDescriptor(testPackage, { path: testPath })).rejects.toThrow();
+    });
+    it("should overwrite existing file when overwrite is true", async () => {
+        const initialPackage = {
+            name: "initial",
+            resources: [
+                {
+                    name: "resource1",
+                    path: path.join(testDir, "data1.csv"),
+                },
+            ],
+        };
+        const updatedPackage = {
+            name: "updated",
+            resources: [
+                {
+                    name: "resource2",
+                    path: path.join(testDir, "data2.csv"),
+                },
+            ],
+            description: "Updated package",
+        };
+        await savePackageDescriptor(initialPackage, { path: testPath });
+        const initialContent = await fs.readFile(testPath, "utf-8");
+        const initialParsed = JSON.parse(initialContent);
+        expect(initialParsed.name).toBe("initial");
+        await savePackageDescriptor(updatedPackage, {
+            path: testPath,
+            overwrite: true,
+        });
+        const updatedContent = await fs.readFile(testPath, "utf-8");
+        const updatedParsed = JSON.parse(updatedContent);
+        expect(updatedParsed.name).toBe("updated");
+        expect(updatedParsed.description).toBe("Updated package");
+    });
+    it("should save package with all metadata fields", async () => {
+        const fullPackage = {
+            name: "full-package",
+            title: "Full Package",
+            description: "A package with all fields",
+            version: "1.0.0",
+            homepage: "https://example.com",
+            keywords: ["test", "data", "package"],
+            created: "2024-01-01T00:00:00Z",
+            image: "https://example.com/image.png",
+            resources: [
+                {
+                    name: "test-resource",
+                    path: path.join(testDir, "data.csv"),
+                },
+            ],
+        };
+        await savePackageDescriptor(fullPackage, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.name).toBe(fullPackage.name);
+        expect(parsedContent.title).toBe(fullPackage.title);
+        expect(parsedContent.description).toBe(fullPackage.description);
+        expect(parsedContent.version).toBe(fullPackage.version);
+        expect(parsedContent.homepage).toBe(fullPackage.homepage);
+        expect(parsedContent.keywords).toEqual(fullPackage.keywords);
+        expect(parsedContent.created).toBe(fullPackage.created);
+        expect(parsedContent.image).toBe(fullPackage.image);
+    });
+    it("should save package with contributors", async () => {
+        const packageWithContributors = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    path: path.join(testDir, "data.csv"),
+                },
+            ],
+            contributors: [
+                {
+                    title: "John Doe",
+                    email: "john@example.com",
+                    role: "author",
+                },
+                {
+                    title: "Jane Smith",
+                    path: "https://example.org",
+                },
+            ],
+        };
+        await savePackageDescriptor(packageWithContributors, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.contributors).toHaveLength(2);
+        expect(parsedContent.contributors[0]?.title).toBe("John Doe");
+        expect(parsedContent.contributors[1]?.title).toBe("Jane Smith");
+    });
+    it("should save package with licenses", async () => {
+        const packageWithLicenses = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    path: path.join(testDir, "data.csv"),
+                },
+            ],
+            licenses: [
+                {
+                    name: "MIT",
+                    path: "https://opensource.org/licenses/MIT",
+                },
+            ],
+        };
+        await savePackageDescriptor(packageWithLicenses, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.licenses).toHaveLength(1);
+        expect(parsedContent.licenses[0]?.name).toBe("MIT");
+    });
+    it("should save package with sources", async () => {
+        const packageWithSources = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    path: path.join(testDir, "data.csv"),
+                },
+            ],
+            sources: [
+                {
+                    title: "Example Source",
+                    path: "https://example.com/data",
+                },
+            ],
+        };
+        await savePackageDescriptor(packageWithSources, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.sources).toHaveLength(1);
+        expect(parsedContent.sources[0]?.title).toBe("Example Source");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"save.spec.js","sourceRoot":"","sources":["../../package/save.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from \"node:fs/promises\"\nimport * as path from \"node:path\"\nimport { temporaryDirectory } from \"tempy\"\nimport { afterEach, beforeEach, describe, expect, it } from \"vitest\"\nimport type { Package } from \"./Package.ts\"\nimport { savePackageDescriptor } from \"./save.ts\"\n\ndescribe(\"savePackageDescriptor\", () => {\n  let testDir: string\n  let testPath: string\n  let testPackage: Package\n\n  beforeEach(() => {\n    testDir = temporaryDirectory()\n    testPath = path.join(testDir, \"datapackage.json\")\n    testPackage = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          path: path.join(testDir, \"data.csv\"),\n        },\n      ],\n    }\n  })\n\n  afterEach(async () => {\n    try {\n      await fs.rm(testDir, { recursive: true, force: true })\n    } catch (error) {\n      if (error instanceof Error && !error.message.includes(\"ENOENT\")) {\n        console.error(`Failed to clean up test directory: ${testDir}`, error)\n      }\n    }\n  })\n\n  it(\"should save a package descriptor to a file and maintain its structure\", async () => {\n    await savePackageDescriptor(testPackage, { path: testPath })\n\n    const fileExists = await fs\n      .stat(testPath)\n      .then(() => true)\n      .catch(() => false)\n    expect(fileExists).toBe(true)\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n\n    const { $schema, ...packageWithoutSchema } = parsedContent\n    expect(packageWithoutSchema.name).toEqual(testPackage.name)\n    expect(packageWithoutSchema.resources).toHaveLength(1)\n    expect(packageWithoutSchema.resources[0].name).toBe(\"test-resource\")\n    expect(packageWithoutSchema.resources[0].path).toBe(\"data.csv\")\n    expect($schema).toBe(\n      \"https://datapackage.org/profiles/2.0/datapackage.json\",\n    )\n  })\n\n  it(\"should add $schema property if not present\", async () => {\n    await savePackageDescriptor(testPackage, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.$schema).toBe(\n      \"https://datapackage.org/profiles/2.0/datapackage.json\",\n    )\n  })\n\n  it(\"should preserve existing $schema property\", async () => {\n    const packageWithSchema: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          path: path.join(testDir, \"data.csv\"),\n        },\n      ],\n      $schema: \"https://custom.schema.url\",\n    }\n\n    await savePackageDescriptor(packageWithSchema, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.$schema).toBe(\"https://custom.schema.url\")\n  })\n\n  it(\"should use pretty formatting with 2-space indentation\", async () => {\n    await savePackageDescriptor(testPackage, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const lines = content.split(\"\\n\")\n    expect(lines.length).toBeGreaterThan(1)\n\n    if (lines.length > 1 && lines[1]) {\n      expect(lines[1].startsWith(\"  \")).toBe(true)\n    }\n  })\n\n  it(\"should save package with multiple resources\", async () => {\n    const packageWithMultipleResources: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"resource1\",\n          path: path.join(testDir, \"data1.csv\"),\n        },\n        {\n          name: \"resource2\",\n          path: path.join(testDir, \"data2.json\"),\n          format: \"json\",\n        },\n      ],\n    }\n\n    await savePackageDescriptor(packageWithMultipleResources, {\n      path: testPath,\n    })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.resources).toHaveLength(2)\n    expect(parsedContent.resources[0]?.name).toBe(\"resource1\")\n    expect(parsedContent.resources[1]?.name).toBe(\"resource2\")\n  })\n\n  it(\"should save package with resource containing schema\", async () => {\n    const packageWithSchema: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          path: path.join(testDir, \"data.csv\"),\n          schema: {\n            fields: [\n              { name: \"id\", type: \"integer\" },\n              { name: \"name\", type: \"string\" },\n            ],\n          },\n        },\n      ],\n    }\n\n    await savePackageDescriptor(packageWithSchema, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.resources[0]?.schema).toEqual(\n      packageWithSchema.resources[0]?.schema,\n    )\n  })\n\n  it(\"should save package with resource containing dialect\", async () => {\n    const packageWithDialect: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          path: path.join(testDir, \"data.csv\"),\n          dialect: {\n            delimiter: \";\",\n            lineTerminator: \"\\n\",\n          },\n        },\n      ],\n    }\n\n    await savePackageDescriptor(packageWithDialect, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.resources[0]?.dialect).toEqual(\n      packageWithDialect.resources[0]?.dialect,\n    )\n  })\n\n  it(\"should save package to a nested directory path\", async () => {\n    const nestedPath = path.join(testDir, \"nested\", \"dir\", \"datapackage.json\")\n    const nestedPackage: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          path: path.join(testDir, \"nested\", \"dir\", \"data.csv\"),\n        },\n      ],\n    }\n\n    await savePackageDescriptor(nestedPackage, { path: nestedPath })\n\n    const fileExists = await fs\n      .stat(nestedPath)\n      .then(() => true)\n      .catch(() => false)\n    expect(fileExists).toBe(true)\n\n    const content = await fs.readFile(nestedPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.name).toBe(nestedPackage.name)\n  })\n\n  it(\"should throw an error when file exists and overwrite is false\", async () => {\n    await savePackageDescriptor(testPackage, { path: testPath })\n\n    await expect(\n      savePackageDescriptor(testPackage, {\n        path: testPath,\n        overwrite: false,\n      }),\n    ).rejects.toThrow()\n  })\n\n  it(\"should throw an error when file exists and overwrite is not specified\", async () => {\n    await savePackageDescriptor(testPackage, { path: testPath })\n\n    await expect(\n      savePackageDescriptor(testPackage, { path: testPath }),\n    ).rejects.toThrow()\n  })\n\n  it(\"should overwrite existing file when overwrite is true\", async () => {\n    const initialPackage: Package = {\n      name: \"initial\",\n      resources: [\n        {\n          name: \"resource1\",\n          path: path.join(testDir, \"data1.csv\"),\n        },\n      ],\n    }\n\n    const updatedPackage: Package = {\n      name: \"updated\",\n      resources: [\n        {\n          name: \"resource2\",\n          path: path.join(testDir, \"data2.csv\"),\n        },\n      ],\n      description: \"Updated package\",\n    }\n\n    await savePackageDescriptor(initialPackage, { path: testPath })\n\n    const initialContent = await fs.readFile(testPath, \"utf-8\")\n    const initialParsed = JSON.parse(initialContent)\n    expect(initialParsed.name).toBe(\"initial\")\n\n    await savePackageDescriptor(updatedPackage, {\n      path: testPath,\n      overwrite: true,\n    })\n\n    const updatedContent = await fs.readFile(testPath, \"utf-8\")\n    const updatedParsed = JSON.parse(updatedContent)\n    expect(updatedParsed.name).toBe(\"updated\")\n    expect(updatedParsed.description).toBe(\"Updated package\")\n  })\n\n  it(\"should save package with all metadata fields\", async () => {\n    const fullPackage: Package = {\n      name: \"full-package\",\n      title: \"Full Package\",\n      description: \"A package with all fields\",\n      version: \"1.0.0\",\n      homepage: \"https://example.com\",\n      keywords: [\"test\", \"data\", \"package\"],\n      created: \"2024-01-01T00:00:00Z\",\n      image: \"https://example.com/image.png\",\n      resources: [\n        {\n          name: \"test-resource\",\n          path: path.join(testDir, \"data.csv\"),\n        },\n      ],\n    }\n\n    await savePackageDescriptor(fullPackage, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.name).toBe(fullPackage.name)\n    expect(parsedContent.title).toBe(fullPackage.title)\n    expect(parsedContent.description).toBe(fullPackage.description)\n    expect(parsedContent.version).toBe(fullPackage.version)\n    expect(parsedContent.homepage).toBe(fullPackage.homepage)\n    expect(parsedContent.keywords).toEqual(fullPackage.keywords)\n    expect(parsedContent.created).toBe(fullPackage.created)\n    expect(parsedContent.image).toBe(fullPackage.image)\n  })\n\n  it(\"should save package with contributors\", async () => {\n    const packageWithContributors: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          path: path.join(testDir, \"data.csv\"),\n        },\n      ],\n      contributors: [\n        {\n          title: \"John Doe\",\n          email: \"john@example.com\",\n          role: \"author\",\n        },\n        {\n          title: \"Jane Smith\",\n          path: \"https://example.org\",\n        },\n      ],\n    }\n\n    await savePackageDescriptor(packageWithContributors, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.contributors).toHaveLength(2)\n    expect(parsedContent.contributors[0]?.title).toBe(\"John Doe\")\n    expect(parsedContent.contributors[1]?.title).toBe(\"Jane Smith\")\n  })\n\n  it(\"should save package with licenses\", async () => {\n    const packageWithLicenses: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          path: path.join(testDir, \"data.csv\"),\n        },\n      ],\n      licenses: [\n        {\n          name: \"MIT\",\n          path: \"https://opensource.org/licenses/MIT\",\n        },\n      ],\n    }\n\n    await savePackageDescriptor(packageWithLicenses, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.licenses).toHaveLength(1)\n    expect(parsedContent.licenses[0]?.name).toBe(\"MIT\")\n  })\n\n  it(\"should save package with sources\", async () => {\n    const packageWithSources: Package = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          path: path.join(testDir, \"data.csv\"),\n        },\n      ],\n      sources: [\n        {\n          title: \"Example Source\",\n          path: \"https://example.com/data\",\n        },\n      ],\n    }\n\n    await savePackageDescriptor(packageWithSources, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.sources).toHaveLength(1)\n    expect(parsedContent.sources[0]?.title).toBe(\"Example Source\")\n  })\n})\n"]}

package/build/package/validate.d.ts

@@ -0,0 +1,12 @@
+import type { Descriptor } from "../descriptor/index.ts";
+import type { Package } from "./Package.ts";
+/**
+ * Validate a Package descriptor (JSON Object) against its profile
+ */
+export declare function validatePackageMetadata(source: Package | Descriptor | string, options?: {
+    basepath?: string;
+}): Promise<{
+    dataPackage: Package | undefined;
+    errors: import("../index.ts").MetadataError[];
+    valid: boolean;
+}>;

package/build/package/validate.js

@@ -0,0 +1,27 @@
+import { loadDescriptor } from "../descriptor/index.js";
+import { validateDescriptor } from "../profile/index.js";
+import { convertPackageFromDescriptor } from "./convert/fromDescriptor.js";
+const DEFAULT_PROFILE = "https://datapackage.org/profiles/1.0/datapackage.json";
+/**
+ * Validate a Package descriptor (JSON Object) against its profile
+ */
+export async function validatePackageMetadata(source, options) {
+    const descriptor = typeof source === "string"
+        ? await loadDescriptor(source)
+        : source;
+    const profile = typeof descriptor.$schema === "string"
+        ? descriptor.$schema
+        : DEFAULT_PROFILE;
+    const report = await validateDescriptor(descriptor, {
+        profile,
+    });
+    let dataPackage = undefined;
+    if (report.valid) {
+        // Validation + normalization = we can cast it
+        dataPackage = convertPackageFromDescriptor(descriptor, {
+            basepath: options?.basepath,
+        });
+    }
+    return { ...report, dataPackage };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/build/package/validate.spec.js

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { useRecording } from "vitest-polly";
+import { loadDescriptor } from "../descriptor/index.js";
+import { validatePackageMetadata } from "./validate.js";
+useRecording();
+describe("validatePackageMetadata", () => {
+    it("returns valid result for valid package", async () => {
+        const descriptor = {
+            name: "example-package",
+            resources: [
+                {
+                    name: "resource-1",
+                    path: "data.csv",
+                },
+            ],
+        };
+        const report = await validatePackageMetadata(descriptor);
+        expect(report.valid).toBe(true);
+        expect(report.errors).toEqual([]);
+    });
+    it("returns validation errors for invalid package", async () => {
+        const descriptor = {
+            name: 123, // Should be a string
+            resources: "not-an-array", // Should be an array
+        };
+        const report = await validatePackageMetadata(descriptor);
+        expect(report.valid).toBe(false);
+        expect(report.errors.length).toBeGreaterThan(0);
+        const error = report.errors[0];
+        expect(error).toBeDefined();
+        if (error) {
+            expect(error.pointer).toBe("/name");
+        }
+    });
+    it("should validate camtrap dp (#144)", async () => {
+        const descriptor = await loadDescriptor("https://raw.githubusercontent.com/tdwg/camtrap-dp/refs/tags/1.0.2/example/datapackage.json");
+        const report = await validatePackageMetadata(descriptor);
+        expect(report.valid).toBe(true);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/path/basepath.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveBasepath(path: string): Promise<string>;
+export declare function getBasepath(path: string): string;

package/build/path/basepath.js

@@ -0,0 +1,25 @@
+import { node } from "../platform/index.js";
+import { isRemotePath } from "./path.js";
+export async function resolveBasepath(path) {
+    const isRemote = isRemotePath(path);
+    // Resolves redirects
+    if (isRemote) {
+        const url = new URL(path);
+        const response = await fetch(url.toString(), { method: "HEAD" });
+        path = response.url;
+    }
+    return getBasepath(path);
+}
+export function getBasepath(path) {
+    const isRemote = isRemotePath(path);
+    if (isRemote) {
+        const normalizedPath = new URL(path).toString();
+        return normalizedPath.split("/").slice(0, -1).join("/");
+    }
+    if (!node) {
+        throw new Error("File system is not supported in this environment");
+    }
+    const resolvedPath = node.path.resolve(path);
+    return node.path.relative(process.cwd(), node.path.parse(resolvedPath).dir);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/build/path/basepath.spec.js

@@ -0,0 +1,55 @@
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { getBasepath } from "./basepath.js";
+describe("getBasepath", () => {
+    it.each([
+        {
+            description: "http URL with file",
+            path: "http://example.com/path/to/file.txt",
+            basepath: "http://example.com/path/to",
+        },
+        {
+            description: "https URL with file",
+            path: "https://example.com/path/to/file.txt",
+            basepath: "https://example.com/path/to",
+        },
+        {
+            description: "URL with query parameters",
+            path: "https://example.com/path/to/file.txt?query=param",
+            basepath: "https://example.com/path/to",
+        },
+        {
+            description: "URL with hash",
+            path: "https://example.com/path/to/file.txt#section",
+            basepath: "https://example.com/path/to",
+        },
+        {
+            description: "URL with no file",
+            path: "https://example.com/path/to/",
+            basepath: "https://example.com/path/to",
+        },
+        {
+            description: "URL with only domain",
+            path: "https://example.com",
+            basepath: "https://example.com",
+        },
+        {
+            description: "local file path",
+            path: "some/path/to/file.txt",
+            basepath: join("some", "path", "to"),
+        },
+        {
+            description: "local path with no file",
+            path: "some/path/to/",
+            basepath: join("some", "path"),
+        },
+        {
+            description: "root level file",
+            path: "file.txt",
+            basepath: "",
+        },
+    ])("$description", ({ path, basepath }) => {
+        expect(getBasepath(path)).toEqual(basepath);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZXBhdGguc3BlYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3BhdGgvYmFzZXBhdGguc3BlYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ2hDLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxNQUFNLFFBQVEsQ0FBQTtBQUM3QyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBRTNDLFFBQVEsQ0FBQyxhQUFhLEVBQUUsR0FBRyxFQUFFO0lBQzNCLEVBQUUsQ0FBQyxJQUFJLENBQUM7UUFDTjtZQUNFLFdBQVcsRUFBRSxvQkFBb0I7WUFDakMsSUFBSSxFQUFFLHFDQUFxQztZQUMzQyxRQUFRLEVBQUUsNEJBQTRCO1NBQ3ZDO1FBQ0Q7WUFDRSxXQUFXLEVBQUUscUJBQXFCO1lBQ2xDLElBQUksRUFBRSxzQ0FBc0M7WUFDNUMsUUFBUSxFQUFFLDZCQUE2QjtTQUN4QztRQUNEO1lBQ0UsV0FBVyxFQUFFLDJCQUEyQjtZQUN4QyxJQUFJLEVBQUUsa0RBQWtEO1lBQ3hELFFBQVEsRUFBRSw2QkFBNkI7U0FDeEM7UUFDRDtZQUNFLFdBQVcsRUFBRSxlQUFlO1lBQzVCLElBQUksRUFBRSw4Q0FBOEM7WUFDcEQsUUFBUSxFQUFFLDZCQUE2QjtTQUN4QztRQUNEO1lBQ0UsV0FBVyxFQUFFLGtCQUFrQjtZQUMvQixJQUFJLEVBQUUsOEJBQThCO1lBQ3BDLFFBQVEsRUFBRSw2QkFBNkI7U0FDeEM7UUFDRDtZQUNFLFdBQVcsRUFBRSxzQkFBc0I7WUFDbkMsSUFBSSxFQUFFLHFCQUFxQjtZQUMzQixRQUFRLEVBQUUscUJBQXFCO1NBQ2hDO1FBQ0Q7WUFDRSxXQUFXLEVBQUUsaUJBQWlCO1lBQzlCLElBQUksRUFBRSx1QkFBdUI7WUFDN0IsUUFBUSxFQUFFLElBQUksQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLElBQUksQ0FBQztTQUNyQztRQUNEO1lBQ0UsV0FBVyxFQUFFLHlCQUF5QjtZQUN0QyxJQUFJLEVBQUUsZUFBZTtZQUNyQixRQUFRLEVBQUUsSUFBSSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUM7U0FDL0I7UUFDRDtZQUNFLFdBQVcsRUFBRSxpQkFBaUI7WUFDOUIsSUFBSSxFQUFFLFVBQVU7WUFDaEIsUUFBUSxFQUFFLEVBQUU7U0FDYjtLQUNGLENBQUMsQ0FBQyxjQUFjLEVBQUUsQ0FBQyxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFO1FBQ3hDLE1BQU0sQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUE7SUFDN0MsQ0FBQyxDQUFDLENBQUE7QUFDSixDQUFDLENBQUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGpvaW4gfSBmcm9tIFwibm9kZTpwYXRoXCJcbmltcG9ydCB7IGRlc2NyaWJlLCBleHBlY3QsIGl0IH0gZnJvbSBcInZpdGVzdFwiXG5pbXBvcnQgeyBnZXRCYXNlcGF0aCB9IGZyb20gXCIuL2Jhc2VwYXRoLnRzXCJcblxuZGVzY3JpYmUoXCJnZXRCYXNlcGF0aFwiLCAoKSA9PiB7XG4gIGl0LmVhY2goW1xuICAgIHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcImh0dHAgVVJMIHdpdGggZmlsZVwiLFxuICAgICAgcGF0aDogXCJodHRwOi8vZXhhbXBsZS5jb20vcGF0aC90by9maWxlLnR4dFwiLFxuICAgICAgYmFzZXBhdGg6IFwiaHR0cDovL2V4YW1wbGUuY29tL3BhdGgvdG9cIixcbiAgICB9LFxuICAgIHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcImh0dHBzIFVSTCB3aXRoIGZpbGVcIixcbiAgICAgIHBhdGg6IFwiaHR0cHM6Ly9leGFtcGxlLmNvbS9wYXRoL3RvL2ZpbGUudHh0XCIsXG4gICAgICBiYXNlcGF0aDogXCJodHRwczovL2V4YW1wbGUuY29tL3BhdGgvdG9cIixcbiAgICB9LFxuICAgIHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcIlVSTCB3aXRoIHF1ZXJ5IHBhcmFtZXRlcnNcIixcbiAgICAgIHBhdGg6IFwiaHR0cHM6Ly9leGFtcGxlLmNvbS9wYXRoL3RvL2ZpbGUudHh0P3F1ZXJ5PXBhcmFtXCIsXG4gICAgICBiYXNlcGF0aDogXCJodHRwczovL2V4YW1wbGUuY29tL3BhdGgvdG9cIixcbiAgICB9LFxuICAgIHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcIlVSTCB3aXRoIGhhc2hcIixcbiAgICAgIHBhdGg6IFwiaHR0cHM6Ly9leGFtcGxlLmNvbS9wYXRoL3RvL2ZpbGUudHh0I3NlY3Rpb25cIixcbiAgICAgIGJhc2VwYXRoOiBcImh0dHBzOi8vZXhhbXBsZS5jb20vcGF0aC90b1wiLFxuICAgIH0sXG4gICAge1xuICAgICAgZGVzY3JpcHRpb246IFwiVVJMIHdpdGggbm8gZmlsZVwiLFxuICAgICAgcGF0aDogXCJodHRwczovL2V4YW1wbGUuY29tL3BhdGgvdG8vXCIsXG4gICAgICBiYXNlcGF0aDogXCJodHRwczovL2V4YW1wbGUuY29tL3BhdGgvdG9cIixcbiAgICB9LFxuICAgIHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcIlVSTCB3aXRoIG9ubHkgZG9tYWluXCIsXG4gICAgICBwYXRoOiBcImh0dHBzOi8vZXhhbXBsZS5jb21cIixcbiAgICAgIGJhc2VwYXRoOiBcImh0dHBzOi8vZXhhbXBsZS5jb21cIixcbiAgICB9LFxuICAgIHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcImxvY2FsIGZpbGUgcGF0aFwiLFxuICAgICAgcGF0aDogXCJzb21lL3BhdGgvdG8vZmlsZS50eHRcIixcbiAgICAgIGJhc2VwYXRoOiBqb2luKFwic29tZVwiLCBcInBhdGhcIiwgXCJ0b1wiKSxcbiAgICB9LFxuICAgIHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcImxvY2FsIHBhdGggd2l0aCBubyBmaWxlXCIsXG4gICAgICBwYXRoOiBcInNvbWUvcGF0aC90by9cIixcbiAgICAgIGJhc2VwYXRoOiBqb2luKFwic29tZVwiLCBcInBhdGhcIiksXG4gICAgfSxcbiAgICB7XG4gICAgICBkZXNjcmlwdGlvbjogXCJyb290IGxldmVsIGZpbGVcIixcbiAgICAgIHBhdGg6IFwiZmlsZS50eHRcIixcbiAgICAgIGJhc2VwYXRoOiBcIlwiLFxuICAgIH0sXG4gIF0pKFwiJGRlc2NyaXB0aW9uXCIsICh7IHBhdGgsIGJhc2VwYXRoIH0pID0+IHtcbiAgICBleHBlY3QoZ2V0QmFzZXBhdGgocGF0aCkpLnRvRXF1YWwoYmFzZXBhdGgpXG4gIH0pXG59KVxuIl19

package/build/path/denormalize.d.ts

@@ -0,0 +1,3 @@
+export declare function denormalizePath(path: string, options: {
+    basepath?: string;
+}): string;

package/build/path/denormalize.js

@@ -0,0 +1,29 @@
+import { node } from "../platform/index.js";
+import { isRemotePath } from "./path.js";
+export function denormalizePath(path, options) {
+    const isPathRemote = isRemotePath(path);
+    const isBasepathRemote = isRemotePath(options.basepath ?? "");
+    if (isPathRemote) {
+        return new URL(path).toString();
+    }
+    if (isBasepathRemote) {
+        const basepath = new URL(options.basepath ?? "").toString();
+        if (!path.startsWith(basepath)) {
+            throw new Error(`Path ${path} is not a subpath of ${options.basepath}`);
+        }
+        const relative = path.replace(`${basepath}/`, "");
+        return relative;
+    }
+    if (!node) {
+        throw new Error("File system is not supported in this environment");
+    }
+    const normalizedPath = node.path.resolve(path);
+    const normalizedBasepath = node.path.resolve(options.basepath ?? "");
+    if (!normalizedPath.startsWith(normalizedBasepath)) {
+        throw new Error(`Path ${path} is not a subpath of ${options.basepath}`);
+    }
+    // The Data Package standard requires "/" as the path separator
+    const relative = node.path.relative(normalizedBasepath, normalizedPath);
+    return relative.split(node.path.sep).join("/");
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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