@frictionless-ts/metadata 1.0.1

package/build/descriptor/Descriptor.d.ts

@@ -0,0 +1,2 @@
+export type Descriptor = Record<string, unknown>;
+export declare function isDescriptor(value: unknown): value is Descriptor;

package/build/descriptor/Descriptor.js

@@ -0,0 +1,4 @@
+export function isDescriptor(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVzY3JpcHRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2Rlc2NyaXB0b3IvRGVzY3JpcHRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLFVBQVUsWUFBWSxDQUFDLEtBQWM7SUFDekMsT0FBTyxDQUFDLENBQUMsS0FBSyxJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUE7QUFDdEUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIERlc2NyaXB0b3IgPSBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPlxuXG5leHBvcnQgZnVuY3Rpb24gaXNEZXNjcmlwdG9yKHZhbHVlOiB1bmtub3duKTogdmFsdWUgaXMgRGVzY3JpcHRvciB7XG4gIHJldHVybiAhIXZhbHVlICYmIHR5cGVvZiB2YWx1ZSA9PT0gXCJvYmplY3RcIiAmJiAhQXJyYXkuaXNBcnJheSh2YWx1ZSlcbn1cbiJdfQ==

package/build/descriptor/index.d.ts

@@ -0,0 +1,6 @@
+export { parseDescriptor } from "./process/parse.ts";
+export { stringifyDescriptor } from "./process/stringify.ts";
+export { loadDescriptor } from "./load.ts";
+export { saveDescriptor } from "./save.ts";
+export type { Descriptor } from "./Descriptor.ts";
+export { isDescriptor } from "./Descriptor.ts";

package/build/descriptor/index.js

@@ -0,0 +1,6 @@
+export { parseDescriptor } from "./process/parse.js";
+export { stringifyDescriptor } from "./process/stringify.js";
+export { loadDescriptor } from "./load.js";
+export { saveDescriptor } from "./save.js";
+export { isDescriptor } from "./Descriptor.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9kZXNjcmlwdG9yL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQTtBQUNwRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQTtBQUM1RCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQzFDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFFMUMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgcGFyc2VEZXNjcmlwdG9yIH0gZnJvbSBcIi4vcHJvY2Vzcy9wYXJzZS50c1wiXG5leHBvcnQgeyBzdHJpbmdpZnlEZXNjcmlwdG9yIH0gZnJvbSBcIi4vcHJvY2Vzcy9zdHJpbmdpZnkudHNcIlxuZXhwb3J0IHsgbG9hZERlc2NyaXB0b3IgfSBmcm9tIFwiLi9sb2FkLnRzXCJcbmV4cG9ydCB7IHNhdmVEZXNjcmlwdG9yIH0gZnJvbSBcIi4vc2F2ZS50c1wiXG5leHBvcnQgdHlwZSB7IERlc2NyaXB0b3IgfSBmcm9tIFwiLi9EZXNjcmlwdG9yLnRzXCJcbmV4cG9ydCB7IGlzRGVzY3JpcHRvciB9IGZyb20gXCIuL0Rlc2NyaXB0b3IudHNcIlxuIl19

package/build/descriptor/load.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Load a descriptor (JSON Object) from a file or URL
+ * Uses dynamic imports to work in both Node.js and browser environments
+ * Supports HTTP, HTTPS, FTP, and FTPS protocols
+ */
+export declare function loadDescriptor(path: string, options?: {
+    onlyRemote?: boolean;
+}): Promise<Record<string, any>>;

package/build/descriptor/load.js

@@ -0,0 +1,36 @@
+import { node } from "../platform/index.js";
+import { getProtocol, isRemotePath } from "../path/index.js";
+import { parseDescriptor } from "./process/parse.js";
+/**
+ * Load a descriptor (JSON Object) from a file or URL
+ * Uses dynamic imports to work in both Node.js and browser environments
+ * Supports HTTP, HTTPS, FTP, and FTPS protocols
+ */
+export async function loadDescriptor(path, options) {
+    const isRemote = isRemotePath(path);
+    if (!isRemote && options?.onlyRemote) {
+        throw new Error("Cannot load descriptor for security reasons");
+    }
+    return !isRemote
+        ? await loadLocalDescriptor(path)
+        : await loadRemoteDescriptor(path);
+}
+async function loadLocalDescriptor(path) {
+    if (!node) {
+        throw new Error("File system is not supported in this environment");
+    }
+    const text = await node.fs.readFile(path, "utf-8");
+    const descriptor = parseDescriptor(text);
+    return descriptor;
+}
+async function loadRemoteDescriptor(path) {
+    const url = new URL(path);
+    const protocol = getProtocol(path);
+    if (!["http", "https", "ftp", "ftps"].includes(protocol)) {
+        throw new Error(`Unsupported remote protocol: ${protocol}`);
+    }
+    const response = await fetch(url.toString());
+    const descriptor = (await response.json());
+    return descriptor;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/descriptor/load.spec.d.ts

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

package/build/descriptor/load.spec.js

@@ -0,0 +1,44 @@
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { loadDescriptor } from "./load.js";
+describe("loadDescriptor", () => {
+    const getFixturePath = (name) => path.relative(process.cwd(), path.join(import.meta.dirname, "fixtures", name ?? ""));
+    const expectedDescriptor = {
+        fields: [
+            {
+                name: "id",
+                type: "integer",
+            },
+            {
+                name: "name",
+                type: "string",
+            },
+        ],
+    };
+    const originalFetch = globalThis.fetch;
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        vi.resetAllMocks();
+    });
+    it("loads a local descriptor from a file path", async () => {
+        const descriptor = await loadDescriptor(getFixturePath("schema.json"));
+        expect(descriptor).toEqual(expectedDescriptor);
+    });
+    it("loads a remote descriptor from a URL", async () => {
+        const testUrl = "https://example.com/schema.json";
+        globalThis.fetch = vi.fn().mockResolvedValue({
+            json: () => Promise.resolve(expectedDescriptor),
+        });
+        const descriptor = await loadDescriptor(testUrl);
+        expect(descriptor).toEqual(expectedDescriptor);
+        expect(fetch).toHaveBeenCalledWith(testUrl);
+    });
+    it("throws error for unsupported URL protocol", async () => {
+        const testUrl = "bad:///path/to/schema.json";
+        await expect(loadDescriptor(testUrl)).rejects.toThrow("Unsupported remote protocol: bad");
+    });
+    it("throws error when onlyRemote is true but path is local", async () => {
+        await expect(loadDescriptor(getFixturePath("schema.json"), { onlyRemote: true })).rejects.toThrow("Cannot load descriptor for security reasons");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/descriptor/process/parse.d.ts

@@ -0,0 +1,2 @@
+import type { Descriptor } from "../Descriptor.ts";
+export declare function parseDescriptor(text: string): Descriptor;

package/build/descriptor/process/parse.js

@@ -0,0 +1,8 @@
+export function parseDescriptor(text) {
+    const value = JSON.parse(text);
+    if (typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`Invalid descriptor: ${text}`);
+    }
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9kZXNjcmlwdG9yL3Byb2Nlc3MvcGFyc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLGVBQWUsQ0FBQyxJQUFZO0lBQzFDLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUE7SUFFOUIsSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3RELE1BQU0sSUFBSSxLQUFLLENBQUMsdUJBQXVCLElBQUksRUFBRSxDQUFDLENBQUE7SUFDaEQsQ0FBQztJQUVELE9BQU8sS0FBbUIsQ0FBQTtBQUM1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBEZXNjcmlwdG9yIH0gZnJvbSBcIi4uL0Rlc2NyaXB0b3IudHNcIlxuXG5leHBvcnQgZnVuY3Rpb24gcGFyc2VEZXNjcmlwdG9yKHRleHQ6IHN0cmluZykge1xuICBjb25zdCB2YWx1ZSA9IEpTT04ucGFyc2UodGV4dClcblxuICBpZiAodHlwZW9mIHZhbHVlICE9PSBcIm9iamVjdFwiIHx8IEFycmF5LmlzQXJyYXkodmFsdWUpKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKGBJbnZhbGlkIGRlc2NyaXB0b3I6ICR7dGV4dH1gKVxuICB9XG5cbiAgcmV0dXJuIHZhbHVlIGFzIERlc2NyaXB0b3Jcbn1cbiJdfQ==

package/build/descriptor/process/stringify.d.ts

@@ -0,0 +1,2 @@
+import type { Descriptor } from "../Descriptor.ts";
+export declare function stringifyDescriptor(descriptor: Descriptor): string;

package/build/descriptor/process/stringify.js

@@ -0,0 +1,4 @@
+export function stringifyDescriptor(descriptor) {
+    return JSON.stringify(descriptor, null, 2);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5naWZ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vZGVzY3JpcHRvci9wcm9jZXNzL3N0cmluZ2lmeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLFVBQVUsbUJBQW1CLENBQUMsVUFBc0I7SUFDeEQsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLFVBQVUsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUE7QUFDNUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRGVzY3JpcHRvciB9IGZyb20gXCIuLi9EZXNjcmlwdG9yLnRzXCJcblxuZXhwb3J0IGZ1bmN0aW9uIHN0cmluZ2lmeURlc2NyaXB0b3IoZGVzY3JpcHRvcjogRGVzY3JpcHRvcikge1xuICByZXR1cm4gSlNPTi5zdHJpbmdpZnkoZGVzY3JpcHRvciwgbnVsbCwgMilcbn1cbiJdfQ==

package/build/descriptor/save.d.ts

@@ -0,0 +1,9 @@
+import type { Descriptor } from "./Descriptor.ts";
+/**
+ * Save a descriptor (JSON Object) to a file path
+ * Works in Node.js environments
+ */
+export declare function saveDescriptor(descriptor: Descriptor, options: {
+    path: string;
+    overwrite?: boolean;
+}): Promise<void>;

package/build/descriptor/save.js

@@ -0,0 +1,19 @@
+import { node } from "../platform/index.js";
+import { stringifyDescriptor } from "./process/stringify.js";
+/**
+ * Save a descriptor (JSON Object) to a file path
+ * Works in Node.js environments
+ */
+export async function saveDescriptor(descriptor, options) {
+    if (!node) {
+        throw new Error("File system is not supported in this environment");
+    }
+    const text = stringifyDescriptor(descriptor);
+    await node.fs.mkdir(node.path.dirname(options.path), { recursive: true });
+    await node.fs.writeFile(options.path, text, {
+        encoding: "utf8",
+        // The "wx" flag ensures that the file won't overwrite an existing file
+        flag: options.overwrite ? "w" : "wx",
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/descriptor/save.spec.d.ts

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

package/build/descriptor/save.spec.js

@@ -0,0 +1,99 @@
+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 { saveDescriptor } from "./save.js";
+describe("saveDescriptor", () => {
+    const testDescriptor = {
+        name: "test-descriptor",
+        version: "1.0.0",
+        description: "Test descriptor for save function",
+        resources: [
+            {
+                name: "resource1",
+                path: "data/resource1.csv",
+            },
+        ],
+    };
+    let testDir;
+    let testPath;
+    beforeEach(() => {
+        testDir = temporaryDirectory();
+        testPath = path.join(testDir, "descriptor.json");
+    });
+    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 descriptor to the specified path", async () => {
+        await saveDescriptor(testDescriptor, { 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);
+        expect(parsedContent).toEqual(testDescriptor);
+    });
+    it("should save a descriptor to a nested directory path", async () => {
+        const nestedPath = path.join(testDir, "nested", "dir", "descriptor.json");
+        await saveDescriptor(testDescriptor, { 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).toEqual(testDescriptor);
+    });
+    it("should use pretty formatting with 2-space indentation", async () => {
+        await saveDescriptor(testDescriptor, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const expectedFormat = JSON.stringify(testDescriptor, null, 2);
+        expect(content).toEqual(expectedFormat);
+        const lines = content.split("\n");
+        expect(lines.length).toBeGreaterThan(1);
+        if (lines.length > 1 && lines[1]) {
+            expect(lines[1].startsWith("  ")).toBe(true);
+        }
+    });
+    it("should throw an error when file exists and overwrite is false", async () => {
+        await saveDescriptor(testDescriptor, { path: testPath });
+        await expect(saveDescriptor(testDescriptor, { path: testPath, overwrite: false })).rejects.toThrow();
+    });
+    it("should throw an error when file exists and overwrite is not specified", async () => {
+        await saveDescriptor(testDescriptor, { path: testPath });
+        await expect(saveDescriptor(testDescriptor, { path: testPath })).rejects.toThrow();
+    });
+    it("should overwrite existing file when overwrite is true", async () => {
+        const initialDescriptor = {
+            name: "initial",
+            version: "1.0.0",
+        };
+        const updatedDescriptor = {
+            name: "updated",
+            version: "2.0.0",
+            description: "Updated descriptor",
+        };
+        await saveDescriptor(initialDescriptor, { path: testPath });
+        const initialContent = await fs.readFile(testPath, "utf-8");
+        const initialParsed = JSON.parse(initialContent);
+        expect(initialParsed).toEqual(initialDescriptor);
+        await saveDescriptor(updatedDescriptor, {
+            path: testPath,
+            overwrite: true,
+        });
+        const updatedContent = await fs.readFile(testPath, "utf-8");
+        const updatedParsed = JSON.parse(updatedContent);
+        expect(updatedParsed).toEqual(updatedDescriptor);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"save.spec.js","sourceRoot":"","sources":["../../descriptor/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 { saveDescriptor } from \"./save.ts\"\n\ndescribe(\"saveDescriptor\", () => {\n  const testDescriptor = {\n    name: \"test-descriptor\",\n    version: \"1.0.0\",\n    description: \"Test descriptor for save function\",\n    resources: [\n      {\n        name: \"resource1\",\n        path: \"data/resource1.csv\",\n      },\n    ],\n  }\n\n  let testDir: string\n  let testPath: string\n\n  beforeEach(() => {\n    testDir = temporaryDirectory()\n    testPath = path.join(testDir, \"descriptor.json\")\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 descriptor to the specified path\", async () => {\n    await saveDescriptor(testDescriptor, { 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    expect(parsedContent).toEqual(testDescriptor)\n  })\n\n  it(\"should save a descriptor to a nested directory path\", async () => {\n    const nestedPath = path.join(testDir, \"nested\", \"dir\", \"descriptor.json\")\n\n    await saveDescriptor(testDescriptor, { 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).toEqual(testDescriptor)\n  })\n\n  it(\"should use pretty formatting with 2-space indentation\", async () => {\n    await saveDescriptor(testDescriptor, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const expectedFormat = JSON.stringify(testDescriptor, null, 2)\n    expect(content).toEqual(expectedFormat)\n\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 throw an error when file exists and overwrite is false\", async () => {\n    await saveDescriptor(testDescriptor, { path: testPath })\n\n    await expect(\n      saveDescriptor(testDescriptor, { path: testPath, overwrite: false }),\n    ).rejects.toThrow()\n  })\n\n  it(\"should throw an error when file exists and overwrite is not specified\", async () => {\n    await saveDescriptor(testDescriptor, { path: testPath })\n\n    await expect(\n      saveDescriptor(testDescriptor, { path: testPath }),\n    ).rejects.toThrow()\n  })\n\n  it(\"should overwrite existing file when overwrite is true\", async () => {\n    const initialDescriptor = {\n      name: \"initial\",\n      version: \"1.0.0\",\n    }\n\n    const updatedDescriptor = {\n      name: \"updated\",\n      version: \"2.0.0\",\n      description: \"Updated descriptor\",\n    }\n\n    await saveDescriptor(initialDescriptor, { path: testPath })\n\n    const initialContent = await fs.readFile(testPath, \"utf-8\")\n    const initialParsed = JSON.parse(initialContent)\n    expect(initialParsed).toEqual(initialDescriptor)\n\n    await saveDescriptor(updatedDescriptor, {\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).toEqual(updatedDescriptor)\n  })\n})\n"]}

package/build/dialect/Dialect.d.ts

@@ -0,0 +1,89 @@
+import type { Metadata } from "../metadata/index.ts";
+/**
+ * Descriptor that describes the structure of tabular data, such as delimiters,
+ * headers, and other features. Following the Data Package standard:
+ * https://datapackage.org/standard/table-dialect/
+ */
+export interface Dialect extends Metadata {
+    /**
+     * JSON schema profile URL for validation
+     */
+    $schema?: string;
+    /**
+     * The name of this dialect
+     */
+    name?: string;
+    /**
+     * Whether the file includes a header row with field names
+     */
+    header?: boolean;
+    /**
+     * Row numbers (zero-based) that are considered header rows
+     */
+    headerRows?: number[];
+    /**
+     * The character used to join multi-line headers
+     */
+    headerJoin?: string;
+    /**
+     * Specific rows to be excluded from the data (zero-based)
+     */
+    commentRows?: number[];
+    /**
+     * Character sequence denoting the start of a comment line
+     */
+    commentChar?: string;
+    /**
+     * The character used to separate fields in the data
+     */
+    delimiter?: string;
+    /**
+     * Character sequence used to terminate rows
+     */
+    lineTerminator?: string;
+    /**
+     * Character used to quote fields
+     */
+    quoteChar?: string;
+    /**
+     * Controls whether a sequence of two quote characters represents a single quote
+     */
+    doubleQuote?: boolean;
+    /**
+     * Character used to escape the delimiter or quote characters
+     */
+    escapeChar?: string;
+    /**
+     * Character sequence representing null or missing values in the data
+     */
+    nullSequence?: string;
+    /**
+     * Whether to ignore whitespace immediately following the delimiter
+     */
+    skipInitialSpace?: boolean;
+    /**
+     * For JSON data, the property name containing the data array
+     */
+    property?: string;
+    /**
+     * The type of data item in the source: 'array' for rows represented as arrays,
+     * or 'object' for rows represented as objects
+     */
+    itemType?: "array" | "object";
+    /**
+     * For object-based data items, specifies which object properties to extract as values
+     */
+    itemKeys?: string[];
+    /**
+     * For spreadsheet data, the sheet number to read (zero-based)
+     */
+    sheetNumber?: number;
+    /**
+     * For spreadsheet data, the sheet name to read
+     */
+    sheetName?: string;
+    /**
+     * For database sources, the table name to read
+     */
+    table?: string;
+}

package/build/dialect/Dialect.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/build/dialect/assert.d.ts

@@ -0,0 +1,6 @@
+import type { Descriptor } from "../descriptor/index.ts";
+import type { Dialect } from "./Dialect.ts";
+/**
+ * Assert a Dialect descriptor (JSON Object) against its profile
+ */
+export declare function assertDialect(source: Descriptor | Dialect): Promise<Dialect>;

package/build/dialect/assert.js

@@ -0,0 +1,12 @@
+import { validateDialect } from "./validate.js";
+/**
+ * Assert a Dialect descriptor (JSON Object) against its profile
+ */
+export async function assertDialect(source) {
+    const report = await validateDialect(source);
+    if (!report.dialect) {
+        throw new Error(`Dialect "${JSON.stringify(source).slice(0, 100)}" is not valid`);
+    }
+    return report.dialect;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzZXJ0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vZGlhbGVjdC9hc3NlcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUUvQzs7R0FFRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsYUFBYSxDQUFDLE1BQTRCO0lBQzlELE1BQU0sTUFBTSxHQUFHLE1BQU0sZUFBZSxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBRTVDLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDcEIsTUFBTSxJQUFJLEtBQUssQ0FDYixZQUFZLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxHQUFHLENBQUMsZ0JBQWdCLENBQ2pFLENBQUE7SUFDSCxDQUFDO0lBRUQsT0FBTyxNQUFNLENBQUMsT0FBTyxDQUFBO0FBQ3ZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IERlc2NyaXB0b3IgfSBmcm9tIFwiLi4vZGVzY3JpcHRvci9pbmRleC50c1wiXG5pbXBvcnQgdHlwZSB7IERpYWxlY3QgfSBmcm9tIFwiLi9EaWFsZWN0LnRzXCJcbmltcG9ydCB7IHZhbGlkYXRlRGlhbGVjdCB9IGZyb20gXCIuL3ZhbGlkYXRlLnRzXCJcblxuLyoqXG4gKiBBc3NlcnQgYSBEaWFsZWN0IGRlc2NyaXB0b3IgKEpTT04gT2JqZWN0KSBhZ2FpbnN0IGl0cyBwcm9maWxlXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBhc3NlcnREaWFsZWN0KHNvdXJjZTogRGVzY3JpcHRvciB8IERpYWxlY3QpIHtcbiAgY29uc3QgcmVwb3J0ID0gYXdhaXQgdmFsaWRhdGVEaWFsZWN0KHNvdXJjZSlcblxuICBpZiAoIXJlcG9ydC5kaWFsZWN0KSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgYERpYWxlY3QgXCIke0pTT04uc3RyaW5naWZ5KHNvdXJjZSkuc2xpY2UoMCwgMTAwKX1cIiBpcyBub3QgdmFsaWRgLFxuICAgIClcbiAgfVxuXG4gIHJldHVybiByZXBvcnQuZGlhbGVjdFxufVxuIl19

package/build/dialect/assert.spec.d.ts

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

package/build/dialect/assert.spec.js

@@ -0,0 +1,22 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { assertDialect } from "./assert.js";
+describe("assertDialect", () => {
+    it("returns typed dialect when valid", async () => {
+        const descriptor = {
+            delimiter: ";",
+            header: true,
+            skipInitialSpace: true,
+        };
+        const dialect = await assertDialect(descriptor);
+        expectTypeOf(dialect).toEqualTypeOf();
+        expect(dialect).toEqual(descriptor);
+    });
+    it("throws Error when dialect is invalid", async () => {
+        const invalidDialect = {
+            delimiter: 1,
+            header: "yes",
+        };
+        await expect(assertDialect(invalidDialect)).rejects.toThrow(Error);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/dialect/convert/fromDescriptor.d.ts

@@ -0,0 +1,2 @@
+import type { Descriptor } from "../../descriptor/index.ts";
+export declare function convertDialectFromDescriptor(descriptor: Descriptor): Descriptor;

package/build/dialect/convert/fromDescriptor.js

@@ -0,0 +1,20 @@
+export function convertDialectFromDescriptor(descriptor) {
+    descriptor = globalThis.structuredClone(descriptor);
+    convertProfile(descriptor);
+    convertTable(descriptor);
+    return descriptor;
+}
+function convertProfile(descriptor) {
+    descriptor.$schema = descriptor.$schema ?? descriptor.profile;
+}
+function convertTable(descriptor) {
+    const table = descriptor.table;
+    if (!table) {
+        return;
+    }
+    if (typeof table !== "string") {
+        descriptor.table = undefined;
+        console.warn(`Ignoring v2.0 incompatible dialect table: ${table}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJvbURlc2NyaXB0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9kaWFsZWN0L2NvbnZlcnQvZnJvbURlc2NyaXB0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLDRCQUE0QixDQUFDLFVBQXNCO0lBQ2pFLFVBQVUsR0FBRyxVQUFVLENBQUMsZUFBZSxDQUFDLFVBQVUsQ0FBQyxDQUFBO0lBRW5ELGNBQWMsQ0FBQyxVQUFVLENBQUMsQ0FBQTtJQUMxQixZQUFZLENBQUMsVUFBVSxDQUFDLENBQUE7SUFFeEIsT0FBTyxVQUFVLENBQUE7QUFDbkIsQ0FBQztBQUVELFNBQVMsY0FBYyxDQUFDLFVBQXNCO0lBQzVDLFVBQVUsQ0FBQyxPQUFPLEdBQUcsVUFBVSxDQUFDLE9BQU8sSUFBSSxVQUFVLENBQUMsT0FBTyxDQUFBO0FBQy9ELENBQUM7QUFFRCxTQUFTLFlBQVksQ0FBQyxVQUFzQjtJQUMxQyxNQUFNLEtBQUssR0FBRyxVQUFVLENBQUMsS0FBSyxDQUFBO0lBQzlCLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNYLE9BQU07SUFDUixDQUFDO0lBRUQsSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUM5QixVQUFVLENBQUMsS0FBSyxHQUFHLFNBQVMsQ0FBQTtRQUM1QixPQUFPLENBQUMsSUFBSSxDQUFDLDZDQUE2QyxLQUFLLEVBQUUsQ0FBQyxDQUFBO0lBQ3BFLENBQUM7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBEZXNjcmlwdG9yIH0gZnJvbSBcIi4uLy4uL2Rlc2NyaXB0b3IvaW5kZXgudHNcIlxuXG5leHBvcnQgZnVuY3Rpb24gY29udmVydERpYWxlY3RGcm9tRGVzY3JpcHRvcihkZXNjcmlwdG9yOiBEZXNjcmlwdG9yKSB7XG4gIGRlc2NyaXB0b3IgPSBnbG9iYWxUaGlzLnN0cnVjdHVyZWRDbG9uZShkZXNjcmlwdG9yKVxuXG4gIGNvbnZlcnRQcm9maWxlKGRlc2NyaXB0b3IpXG4gIGNvbnZlcnRUYWJsZShkZXNjcmlwdG9yKVxuXG4gIHJldHVybiBkZXNjcmlwdG9yXG59XG5cbmZ1bmN0aW9uIGNvbnZlcnRQcm9maWxlKGRlc2NyaXB0b3I6IERlc2NyaXB0b3IpIHtcbiAgZGVzY3JpcHRvci4kc2NoZW1hID0gZGVzY3JpcHRvci4kc2NoZW1hID8/IGRlc2NyaXB0b3IucHJvZmlsZVxufVxuXG5mdW5jdGlvbiBjb252ZXJ0VGFibGUoZGVzY3JpcHRvcjogRGVzY3JpcHRvcikge1xuICBjb25zdCB0YWJsZSA9IGRlc2NyaXB0b3IudGFibGVcbiAgaWYgKCF0YWJsZSkge1xuICAgIHJldHVyblxuICB9XG5cbiAgaWYgKHR5cGVvZiB0YWJsZSAhPT0gXCJzdHJpbmdcIikge1xuICAgIGRlc2NyaXB0b3IudGFibGUgPSB1bmRlZmluZWRcbiAgICBjb25zb2xlLndhcm4oYElnbm9yaW5nIHYyLjAgaW5jb21wYXRpYmxlIGRpYWxlY3QgdGFibGU6ICR7dGFibGV9YClcbiAgfVxufVxuIl19

package/build/dialect/convert/toDescriptor.d.ts

@@ -0,0 +1,3 @@
+import type { Descriptor } from "../../descriptor/index.ts";
+import type { Dialect } from "../Dialect.ts";
+export declare function convertDialectToDescriptor(dialect: Dialect): Descriptor;

package/build/dialect/convert/toDescriptor.js

@@ -0,0 +1,5 @@
+export function convertDialectToDescriptor(dialect) {
+    dialect = globalThis.structuredClone(dialect);
+    return dialect;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9EZXNjcmlwdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vZGlhbGVjdC9jb252ZXJ0L3RvRGVzY3JpcHRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLFVBQVUsMEJBQTBCLENBQUMsT0FBZ0I7SUFDekQsT0FBTyxHQUFHLFVBQVUsQ0FBQyxlQUFlLENBQUMsT0FBTyxDQUFDLENBQUE7SUFFN0MsT0FBTyxPQUFxQixDQUFBO0FBQzlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IERlc2NyaXB0b3IgfSBmcm9tIFwiLi4vLi4vZGVzY3JpcHRvci9pbmRleC50c1wiXG5pbXBvcnQgdHlwZSB7IERpYWxlY3QgfSBmcm9tIFwiLi4vRGlhbGVjdC50c1wiXG5cbmV4cG9ydCBmdW5jdGlvbiBjb252ZXJ0RGlhbGVjdFRvRGVzY3JpcHRvcihkaWFsZWN0OiBEaWFsZWN0KSB7XG4gIGRpYWxlY3QgPSBnbG9iYWxUaGlzLnN0cnVjdHVyZWRDbG9uZShkaWFsZWN0KVxuXG4gIHJldHVybiBkaWFsZWN0IGFzIERlc2NyaXB0b3Jcbn1cbiJdfQ==

package/build/dialect/index.d.ts

@@ -0,0 +1,8 @@
+export { assertDialect } from "./assert.ts";
+export { validateDialect } from "./validate.ts";
+export type { Dialect } from "./Dialect.ts";
+export { loadDialect } from "./load.ts";
+export { saveDialect } from "./save.ts";
+export { convertDialectFromDescriptor } from "./convert/fromDescriptor.ts";
+export { convertDialectToDescriptor } from "./convert/toDescriptor.ts";
+export { resolveDialect } from "./resolve.ts";

package/build/dialect/index.js

@@ -0,0 +1,8 @@
+export { assertDialect } from "./assert.js";
+export { validateDialect } from "./validate.js";
+export { loadDialect } from "./load.js";
+export { saveDialect } from "./save.js";
+export { convertDialectFromDescriptor } from "./convert/fromDescriptor.js";
+export { convertDialectToDescriptor } from "./convert/toDescriptor.js";
+export { resolveDialect } from "./resolve.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9kaWFsZWN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxhQUFhLENBQUE7QUFDM0MsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUUvQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ3ZDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDdkMsT0FBTyxFQUFFLDRCQUE0QixFQUFFLE1BQU0sNkJBQTZCLENBQUE7QUFDMUUsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0sMkJBQTJCLENBQUE7QUFDdEUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGNBQWMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGFzc2VydERpYWxlY3QgfSBmcm9tIFwiLi9hc3NlcnQudHNcIlxuZXhwb3J0IHsgdmFsaWRhdGVEaWFsZWN0IH0gZnJvbSBcIi4vdmFsaWRhdGUudHNcIlxuZXhwb3J0IHR5cGUgeyBEaWFsZWN0IH0gZnJvbSBcIi4vRGlhbGVjdC50c1wiXG5leHBvcnQgeyBsb2FkRGlhbGVjdCB9IGZyb20gXCIuL2xvYWQudHNcIlxuZXhwb3J0IHsgc2F2ZURpYWxlY3QgfSBmcm9tIFwiLi9zYXZlLnRzXCJcbmV4cG9ydCB7IGNvbnZlcnREaWFsZWN0RnJvbURlc2NyaXB0b3IgfSBmcm9tIFwiLi9jb252ZXJ0L2Zyb21EZXNjcmlwdG9yLnRzXCJcbmV4cG9ydCB7IGNvbnZlcnREaWFsZWN0VG9EZXNjcmlwdG9yIH0gZnJvbSBcIi4vY29udmVydC90b0Rlc2NyaXB0b3IudHNcIlxuZXhwb3J0IHsgcmVzb2x2ZURpYWxlY3QgfSBmcm9tIFwiLi9yZXNvbHZlLnRzXCJcbiJdfQ==

package/build/dialect/load.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Load a Dialect descriptor (JSON Object) from a file or URL
+ * Ensures the descriptor is valid against its profile
+ */
+export declare function loadDialect(path: string): Promise<import("./Dialect.ts").Dialect>;

package/build/dialect/load.js

@@ -0,0 +1,12 @@
+import { loadDescriptor } from "../descriptor/index.js";
+import { assertDialect } from "./assert.js";
+/**
+ * Load a Dialect descriptor (JSON Object) from a file or URL
+ * Ensures the descriptor is valid against its profile
+ */
+export async function loadDialect(path) {
+    const descriptor = await loadDescriptor(path);
+    const dialect = await assertDialect(descriptor);
+    return dialect;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2RpYWxlY3QvbG9hZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sd0JBQXdCLENBQUE7QUFDdkQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUUzQzs7O0dBR0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLFdBQVcsQ0FBQyxJQUFZO0lBQzVDLE1BQU0sVUFBVSxHQUFHLE1BQU0sY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFBO0lBQzdDLE1BQU0sT0FBTyxHQUFHLE1BQU0sYUFBYSxDQUFDLFVBQVUsQ0FBQyxDQUFBO0lBQy9DLE9BQU8sT0FBTyxDQUFBO0FBQ2hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBsb2FkRGVzY3JpcHRvciB9IGZyb20gXCIuLi9kZXNjcmlwdG9yL2luZGV4LnRzXCJcbmltcG9ydCB7IGFzc2VydERpYWxlY3QgfSBmcm9tIFwiLi9hc3NlcnQudHNcIlxuXG4vKipcbiAqIExvYWQgYSBEaWFsZWN0IGRlc2NyaXB0b3IgKEpTT04gT2JqZWN0KSBmcm9tIGEgZmlsZSBvciBVUkxcbiAqIEVuc3VyZXMgdGhlIGRlc2NyaXB0b3IgaXMgdmFsaWQgYWdhaW5zdCBpdHMgcHJvZmlsZVxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gbG9hZERpYWxlY3QocGF0aDogc3RyaW5nKSB7XG4gIGNvbnN0IGRlc2NyaXB0b3IgPSBhd2FpdCBsb2FkRGVzY3JpcHRvcihwYXRoKVxuICBjb25zdCBkaWFsZWN0ID0gYXdhaXQgYXNzZXJ0RGlhbGVjdChkZXNjcmlwdG9yKVxuICByZXR1cm4gZGlhbGVjdFxufVxuIl19

package/build/dialect/load.spec.d.ts

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

package/build/dialect/load.spec.js

@@ -0,0 +1,18 @@
+import { join } from "node:path";
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { loadDialect } from "./load.js";
+describe("loadDialect", async () => {
+    const getFixturePath = (name) => join(import.meta.dirname, "fixtures", name);
+    const descriptor = {
+        delimiter: ";",
+    };
+    it("loads a dialect from a local file path", async () => {
+        const dialect = await loadDialect(getFixturePath("dialect.json"));
+        expectTypeOf(dialect).toEqualTypeOf();
+        expect(dialect).toEqual(descriptor);
+    });
+    it("throws an error when dialect is invalid", async () => {
+        await expect(loadDialect(getFixturePath("dialect-invalid.json"))).rejects.toThrow();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/dialect/resolve.d.ts

@@ -0,0 +1,2 @@
+import type { Dialect } from "./Dialect.ts";
+export declare function resolveDialect(dialect?: Dialect | string): Promise<Dialect | undefined>;

package/build/dialect/resolve.js

@@ -0,0 +1,11 @@
+import { loadDialect } from "../dialect/index.js";
+export async function resolveDialect(dialect) {
+    if (!dialect) {
+        return undefined;
+    }
+    if (typeof dialect !== "string") {
+        return dialect;
+    }
+    return await loadDialect(dialect);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb2x2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2RpYWxlY3QvcmVzb2x2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0scUJBQXFCLENBQUE7QUFHakQsTUFBTSxDQUFDLEtBQUssVUFBVSxjQUFjLENBQUMsT0FBMEI7SUFDN0QsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ2IsT0FBTyxTQUFTLENBQUE7SUFDbEIsQ0FBQztJQUVELElBQUksT0FBTyxPQUFPLEtBQUssUUFBUSxFQUFFLENBQUM7UUFDaEMsT0FBTyxPQUFPLENBQUE7SUFDaEIsQ0FBQztJQUVELE9BQU8sTUFBTSxXQUFXLENBQUMsT0FBTyxDQUFDLENBQUE7QUFDbkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGxvYWREaWFsZWN0IH0gZnJvbSBcIi4uL2RpYWxlY3QvaW5kZXgudHNcIlxuaW1wb3J0IHR5cGUgeyBEaWFsZWN0IH0gZnJvbSBcIi4vRGlhbGVjdC50c1wiXG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiByZXNvbHZlRGlhbGVjdChkaWFsZWN0PzogRGlhbGVjdCB8IHN0cmluZykge1xuICBpZiAoIWRpYWxlY3QpIHtcbiAgICByZXR1cm4gdW5kZWZpbmVkXG4gIH1cblxuICBpZiAodHlwZW9mIGRpYWxlY3QgIT09IFwic3RyaW5nXCIpIHtcbiAgICByZXR1cm4gZGlhbGVjdFxuICB9XG5cbiAgcmV0dXJuIGF3YWl0IGxvYWREaWFsZWN0KGRpYWxlY3QpXG59XG4iXX0=

package/build/dialect/save.d.ts

@@ -0,0 +1,9 @@
+import type { Dialect } from "./Dialect.ts";
+/**
+ * Save a Dialect to a file path
+ * Works in Node.js environments
+ */
+export declare function saveDialect(dialect: Dialect, options: {
+    path: string;
+    overwrite?: boolean;
+}): Promise<void>;