livemark 0.2.0

package/README.md

@@ -0,0 +1,3 @@
+# Livemark
+
+Livemark implementation in TypeScript

package/build/descriptor/index.d.ts

@@ -0,0 +1,3 @@
+export { loadDescriptor } from "./load.js";
+export { saveDescriptor } from "./save.js";
+export { validateDescriptor } from "./validate.js";

package/build/descriptor/index.js

@@ -0,0 +1,4 @@
+export { loadDescriptor } from "./load.js";
+export { saveDescriptor } from "./save.js";
+export { validateDescriptor } from "./validate.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9kZXNjcmlwdG9yL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDMUMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUMxQyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxlQUFlLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBsb2FkRGVzY3JpcHRvciB9IGZyb20gXCIuL2xvYWQuanNcIlxuZXhwb3J0IHsgc2F2ZURlc2NyaXB0b3IgfSBmcm9tIFwiLi9zYXZlLmpzXCJcbmV4cG9ydCB7IHZhbGlkYXRlRGVzY3JpcHRvciB9IGZyb20gXCIuL3ZhbGlkYXRlLmpzXCJcbiJdfQ==

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(props: {
+    path: string;
+}): Promise<Record<string, any>>;

package/build/descriptor/load.js

@@ -0,0 +1,40 @@
+import { loadNodeApis } from "./node.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(props) {
+    const url = createRemoteUrl(props.path);
+    return url
+        ? await loadRemoteDescriptor(url)
+        : await loadLocalDescriptor(props.path);
+}
+function createRemoteUrl(path) {
+    try {
+        return new URL(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+const REMOTE_PROTOCOLS = ["http:", "https:", "ftp:", "ftps:"];
+async function loadRemoteDescriptor(url) {
+    const protocol = url.protocol.toLowerCase();
+    if (!REMOTE_PROTOCOLS.includes(protocol)) {
+        throw new Error(`Unsupported URL protocol: ${protocol}`);
+    }
+    const response = await fetch(url.toString());
+    const descriptor = (await response.json());
+    return descriptor;
+}
+async function loadLocalDescriptor(path) {
+    const node = await loadNodeApis();
+    if (!node) {
+        throw new Error("File system is not supported in this environment");
+    }
+    const content = await node.fs.readFile(path, "utf-8");
+    const descriptor = JSON.parse(content);
+    return descriptor;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/descriptor/node.d.ts

@@ -0,0 +1,125 @@
+export declare function loadNodeApis(): Promise<{
+    fs: {
+        default: typeof import("node:fs/promises");
+        access(path: import("fs").PathLike, mode?: number): Promise<void>;
+        copyFile(src: import("fs").PathLike, dest: import("fs").PathLike, mode?: number): Promise<void>;
+        open(path: import("fs").PathLike, flags?: string | number, mode?: import("fs").Mode): Promise<import("fs/promises").FileHandle>;
+        rename(oldPath: import("fs").PathLike, newPath: import("fs").PathLike): Promise<void>;
+        truncate(path: import("fs").PathLike, len?: number): Promise<void>;
+        rmdir(path: import("fs").PathLike, options?: import("fs").RmDirOptions): Promise<void>;
+        rm(path: import("fs").PathLike, options?: import("fs").RmOptions): Promise<void>;
+        mkdir(path: import("fs").PathLike, options: import("fs").MakeDirectoryOptions & {
+            recursive: true;
+        }): Promise<string | undefined>;
+        mkdir(path: import("fs").PathLike, options?: import("fs").Mode | (import("fs").MakeDirectoryOptions & {
+            recursive?: false | undefined;
+        }) | null): Promise<void>;
+        mkdir(path: import("fs").PathLike, options?: import("fs").Mode | import("fs").MakeDirectoryOptions | null): Promise<string | undefined>;
+        readdir(path: import("fs").PathLike, options?: (import("fs").ObjectEncodingOptions & {
+            withFileTypes?: false | undefined;
+            recursive?: boolean | undefined;
+        }) | BufferEncoding | null): Promise<string[]>;
+        readdir(path: import("fs").PathLike, options: {
+            encoding: "buffer";
+            withFileTypes?: false | undefined;
+            recursive?: boolean | undefined;
+        } | "buffer"): Promise<Buffer[]>;
+        readdir(path: import("fs").PathLike, options?: (import("fs").ObjectEncodingOptions & {
+            withFileTypes?: false | undefined;
+            recursive?: boolean | undefined;
+        }) | BufferEncoding | null): Promise<string[] | Buffer[]>;
+        readdir(path: import("fs").PathLike, options: import("fs").ObjectEncodingOptions & {
+            withFileTypes: true;
+            recursive?: boolean | undefined;
+        }): Promise<import("fs").Dirent[]>;
+        readlink(path: import("fs").PathLike, options?: import("fs").ObjectEncodingOptions | BufferEncoding | null): Promise<string>;
+        readlink(path: import("fs").PathLike, options: import("fs").BufferEncodingOption): Promise<Buffer>;
+        readlink(path: import("fs").PathLike, options?: import("fs").ObjectEncodingOptions | string | null): Promise<string | Buffer>;
+        symlink(target: import("fs").PathLike, path: import("fs").PathLike, type?: string | null): Promise<void>;
+        lstat(path: import("fs").PathLike, opts?: import("fs").StatOptions & {
+            bigint?: false | undefined;
+        }): Promise<import("fs").Stats>;
+        lstat(path: import("fs").PathLike, opts: import("fs").StatOptions & {
+            bigint: true;
+        }): Promise<import("fs").BigIntStats>;
+        lstat(path: import("fs").PathLike, opts?: import("fs").StatOptions): Promise<import("fs").Stats | import("fs").BigIntStats>;
+        stat(path: import("fs").PathLike, opts?: import("fs").StatOptions & {
+            bigint?: false | undefined;
+        }): Promise<import("fs").Stats>;
+        stat(path: import("fs").PathLike, opts: import("fs").StatOptions & {
+            bigint: true;
+        }): Promise<import("fs").BigIntStats>;
+        stat(path: import("fs").PathLike, opts?: import("fs").StatOptions): Promise<import("fs").Stats | import("fs").BigIntStats>;
+        statfs(path: import("fs").PathLike, opts?: import("fs").StatFsOptions & {
+            bigint?: false | undefined;
+        }): Promise<import("fs").StatsFs>;
+        statfs(path: import("fs").PathLike, opts: import("fs").StatFsOptions & {
+            bigint: true;
+        }): Promise<import("fs").BigIntStatsFs>;
+        statfs(path: import("fs").PathLike, opts?: import("fs").StatFsOptions): Promise<import("fs").StatsFs | import("fs").BigIntStatsFs>;
+        link(existingPath: import("fs").PathLike, newPath: import("fs").PathLike): Promise<void>;
+        unlink(path: import("fs").PathLike): Promise<void>;
+        chmod(path: import("fs").PathLike, mode: import("fs").Mode): Promise<void>;
+        lchmod(path: import("fs").PathLike, mode: import("fs").Mode): Promise<void>;
+        lchown(path: import("fs").PathLike, uid: number, gid: number): Promise<void>;
+        lutimes(path: import("fs").PathLike, atime: import("fs").TimeLike, mtime: import("fs").TimeLike): Promise<void>;
+        chown(path: import("fs").PathLike, uid: number, gid: number): Promise<void>;
+        utimes(path: import("fs").PathLike, atime: import("fs").TimeLike, mtime: import("fs").TimeLike): Promise<void>;
+        realpath(path: import("fs").PathLike, options?: import("fs").ObjectEncodingOptions | BufferEncoding | null): Promise<string>;
+        realpath(path: import("fs").PathLike, options: import("fs").BufferEncodingOption): Promise<Buffer>;
+        realpath(path: import("fs").PathLike, options?: import("fs").ObjectEncodingOptions | BufferEncoding | null): Promise<string | Buffer>;
+        mkdtemp(prefix: string, options?: import("fs").ObjectEncodingOptions | BufferEncoding | null): Promise<string>;
+        mkdtemp(prefix: string, options: import("fs").BufferEncodingOption): Promise<Buffer>;
+        mkdtemp(prefix: string, options?: import("fs").ObjectEncodingOptions | BufferEncoding | null): Promise<string | Buffer>;
+        writeFile(file: import("fs").PathLike | import("fs/promises").FileHandle, data: string | NodeJS.ArrayBufferView | Iterable<string | NodeJS.ArrayBufferView> | AsyncIterable<string | NodeJS.ArrayBufferView> | import("stream"), options?: (import("fs").ObjectEncodingOptions & {
+            mode?: import("fs").Mode | undefined;
+            flag?: import("fs").OpenMode | undefined;
+            flush?: boolean | undefined;
+        } & import("events").Abortable) | BufferEncoding | null): Promise<void>;
+        appendFile(path: import("fs").PathLike | import("fs/promises").FileHandle, data: string | Uint8Array, options?: (import("fs").ObjectEncodingOptions & import("fs/promises").FlagAndOpenMode & {
+            flush?: boolean | undefined;
+        }) | BufferEncoding | null): Promise<void>;
+        readFile(path: import("fs").PathLike | import("fs/promises").FileHandle, options?: ({
+            encoding?: null | undefined;
+            flag?: import("fs").OpenMode | undefined;
+        } & import("events").Abortable) | null): Promise<Buffer>;
+        readFile(path: import("fs").PathLike | import("fs/promises").FileHandle, options: ({
+            encoding: BufferEncoding;
+            flag?: import("fs").OpenMode | undefined;
+        } & import("events").Abortable) | BufferEncoding): Promise<string>;
+        readFile(path: import("fs").PathLike | import("fs/promises").FileHandle, options?: (import("fs").ObjectEncodingOptions & import("events").Abortable & {
+            flag?: import("fs").OpenMode | undefined;
+        }) | BufferEncoding | null): Promise<string | Buffer>;
+        opendir(path: import("fs").PathLike, options?: import("fs").OpenDirOptions): Promise<import("fs").Dir>;
+        watch(filename: import("fs").PathLike, options: (import("fs").WatchOptions & {
+            encoding: "buffer";
+        }) | "buffer"): AsyncIterable<import("fs/promises").FileChangeInfo<Buffer>>;
+        watch(filename: import("fs").PathLike, options?: import("fs").WatchOptions | BufferEncoding): AsyncIterable<import("fs/promises").FileChangeInfo<string>>;
+        watch(filename: import("fs").PathLike, options: import("fs").WatchOptions | string): AsyncIterable<import("fs/promises").FileChangeInfo<string>> | AsyncIterable<import("fs/promises").FileChangeInfo<Buffer>>;
+        cp(source: string | URL, destination: string | URL, opts?: import("fs").CopyOptions): Promise<void>;
+        glob(pattern: string | string[]): NodeJS.AsyncIterator<string>;
+        glob(pattern: string | string[], opt: import("fs").GlobOptionsWithFileTypes): NodeJS.AsyncIterator<import("fs").Dirent>;
+        glob(pattern: string | string[], opt: import("fs").GlobOptionsWithoutFileTypes): NodeJS.AsyncIterator<string>;
+        glob(pattern: string | string[], opt: import("fs").GlobOptions): NodeJS.AsyncIterator<import("fs").Dirent | string>;
+        constants: typeof import("fs").constants;
+    };
+    path: {
+        default: import("path").PlatformPath;
+        normalize(path: string): string;
+        join(...paths: string[]): string;
+        resolve(...paths: string[]): string;
+        matchesGlob(path: string, pattern: string): boolean;
+        isAbsolute(path: string): boolean;
+        relative(from: string, to: string): string;
+        dirname(path: string): string;
+        basename(path: string, suffix?: string): string;
+        extname(path: string): string;
+        sep: "\\" | "/";
+        delimiter: ";" | ":";
+        parse(path: string): import("path").ParsedPath;
+        format(pathObject: import("path").FormatInputPathObject): string;
+        toNamespacedPath(path: string): string;
+        posix: import("path").PlatformPath;
+        win32: import("path").PlatformPath;
+    };
+} | undefined>;

package/build/descriptor/node.js

@@ -0,0 +1,9 @@
+export async function loadNodeApis() {
+    if (globalThis.process) {
+        const fs = await import("node:fs/promises");
+        const path = await import("node:path");
+        return { fs, path };
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2Rlc2NyaXB0b3Ivbm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsS0FBSyxVQUFVLFlBQVk7SUFDaEMsSUFBSSxVQUFVLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDdkIsTUFBTSxFQUFFLEdBQUcsTUFBTSxNQUFNLENBQUMsa0JBQWtCLENBQUMsQ0FBQTtRQUMzQyxNQUFNLElBQUksR0FBRyxNQUFNLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQTtRQUN0QyxPQUFPLEVBQUUsRUFBRSxFQUFFLElBQUksRUFBRSxDQUFBO0lBQ3JCLENBQUM7SUFFRCxPQUFPLFNBQVMsQ0FBQTtBQUNsQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGxvYWROb2RlQXBpcygpIHtcbiAgaWYgKGdsb2JhbFRoaXMucHJvY2Vzcykge1xuICAgIGNvbnN0IGZzID0gYXdhaXQgaW1wb3J0KFwibm9kZTpmcy9wcm9taXNlc1wiKVxuICAgIGNvbnN0IHBhdGggPSBhd2FpdCBpbXBvcnQoXCJub2RlOnBhdGhcIilcbiAgICByZXR1cm4geyBmcywgcGF0aCB9XG4gIH1cblxuICByZXR1cm4gdW5kZWZpbmVkXG59XG4iXX0=

package/build/descriptor/save.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Save a descriptor (JSON Object) to a file path
+ * Works in Node.js environments
+ */
+export declare function saveDescriptor(props: {
+    descriptor: Record<string, any>;
+    path: string;
+}): Promise<boolean>;

package/build/descriptor/save.js

@@ -0,0 +1,17 @@
+import { loadNodeApis } from "./node.js";
+/**
+ * Save a descriptor (JSON Object) to a file path
+ * Works in Node.js environments
+ */
+export async function saveDescriptor(props) {
+    const { descriptor, path } = props;
+    const node = await loadNodeApis();
+    if (!node) {
+        throw new Error("File system is not supported in this environment");
+    }
+    const content = JSON.stringify(descriptor, null, 2);
+    await node.fs.mkdir(node.path.dirname(path), { recursive: true });
+    await node.fs.writeFile(path, content, "utf-8");
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2F2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2Rlc2NyaXB0b3Ivc2F2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBRXhDOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsY0FBYyxDQUFDLEtBR3BDO0lBQ0MsTUFBTSxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUUsR0FBRyxLQUFLLENBQUE7SUFFbEMsTUFBTSxJQUFJLEdBQUcsTUFBTSxZQUFZLEVBQUUsQ0FBQTtJQUNqQyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDVixNQUFNLElBQUksS0FBSyxDQUFDLGtEQUFrRCxDQUFDLENBQUE7SUFDckUsQ0FBQztJQUVELE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsVUFBVSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQTtJQUVuRCxNQUFNLElBQUksQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUE7SUFDakUsTUFBTSxJQUFJLENBQUMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFBO0lBRS9DLE9BQU8sSUFBSSxDQUFBO0FBQ2IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGxvYWROb2RlQXBpcyB9IGZyb20gXCIuL25vZGUuanNcIlxuXG4vKipcbiAqIFNhdmUgYSBkZXNjcmlwdG9yIChKU09OIE9iamVjdCkgdG8gYSBmaWxlIHBhdGhcbiAqIFdvcmtzIGluIE5vZGUuanMgZW52aXJvbm1lbnRzXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBzYXZlRGVzY3JpcHRvcihwcm9wczoge1xuICBkZXNjcmlwdG9yOiBSZWNvcmQ8c3RyaW5nLCBhbnk+XG4gIHBhdGg6IHN0cmluZ1xufSkge1xuICBjb25zdCB7IGRlc2NyaXB0b3IsIHBhdGggfSA9IHByb3BzXG5cbiAgY29uc3Qgbm9kZSA9IGF3YWl0IGxvYWROb2RlQXBpcygpXG4gIGlmICghbm9kZSkge1xuICAgIHRocm93IG5ldyBFcnJvcihcIkZpbGUgc3lzdGVtIGlzIG5vdCBzdXBwb3J0ZWQgaW4gdGhpcyBlbnZpcm9ubWVudFwiKVxuICB9XG5cbiAgY29uc3QgY29udGVudCA9IEpTT04uc3RyaW5naWZ5KGRlc2NyaXB0b3IsIG51bGwsIDIpXG5cbiAgYXdhaXQgbm9kZS5mcy5ta2Rpcihub2RlLnBhdGguZGlybmFtZShwYXRoKSwgeyByZWN1cnNpdmU6IHRydWUgfSlcbiAgYXdhaXQgbm9kZS5mcy53cml0ZUZpbGUocGF0aCwgY29udGVudCwgXCJ1dGYtOFwiKVxuXG4gIHJldHVybiB0cnVlXG59XG4iXX0=

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

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

package/build/descriptor/save.spec.js

@@ -0,0 +1,80 @@
+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 () => {
+        const result = await saveDescriptor({
+            descriptor: testDescriptor,
+            path: testPath,
+        });
+        expect(result).toBe(true);
+        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");
+        const result = await saveDescriptor({
+            descriptor: testDescriptor,
+            path: nestedPath,
+        });
+        expect(result).toBe(true);
+        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({
+            descriptor: 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);
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/descriptor/validate.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Validate a descriptor (JSON Object) against a JSON Schema
+ * It uses Ajv for JSON Schema validation under the hood
+ * It returns a list of errors (empty if valid)
+ */
+export declare function validateDescriptor(props: {
+    descriptor: Record<string, any>;
+    profile: Record<string, any>;
+}): Promise<import("ajv").ErrorObject<string, Record<string, any>, unknown>[]>;

package/build/descriptor/validate.js

@@ -0,0 +1,14 @@
+import { Ajv } from "ajv";
+/**
+ * Validate a descriptor (JSON Object) against a JSON Schema
+ * It uses Ajv for JSON Schema validation under the hood
+ * It returns a list of errors (empty if valid)
+ */
+export async function validateDescriptor(props) {
+    const { descriptor, profile } = props;
+    const ajv = new Ajv();
+    const validate = ajv.compile(profile);
+    validate(descriptor);
+    return validate.errors ?? [];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9kZXNjcmlwdG9yL3ZhbGlkYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxLQUFLLENBQUE7QUFFekI7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsa0JBQWtCLENBQUMsS0FHeEM7SUFDQyxNQUFNLEVBQUUsVUFBVSxFQUFFLE9BQU8sRUFBRSxHQUFHLEtBQUssQ0FBQTtJQUVyQyxNQUFNLEdBQUcsR0FBRyxJQUFJLEdBQUcsRUFBRSxDQUFBO0lBQ3JCLE1BQU0sUUFBUSxHQUFHLEdBQUcsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUE7SUFDckMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxDQUFBO0lBQ3BCLE9BQU8sUUFBUSxDQUFDLE1BQU0sSUFBSSxFQUFFLENBQUE7QUFDOUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFqdiB9IGZyb20gXCJhanZcIlxuXG4vKipcbiAqIFZhbGlkYXRlIGEgZGVzY3JpcHRvciAoSlNPTiBPYmplY3QpIGFnYWluc3QgYSBKU09OIFNjaGVtYVxuICogSXQgdXNlcyBBanYgZm9yIEpTT04gU2NoZW1hIHZhbGlkYXRpb24gdW5kZXIgdGhlIGhvb2RcbiAqIEl0IHJldHVybnMgYSBsaXN0IG9mIGVycm9ycyAoZW1wdHkgaWYgdmFsaWQpXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiB2YWxpZGF0ZURlc2NyaXB0b3IocHJvcHM6IHtcbiAgZGVzY3JpcHRvcjogUmVjb3JkPHN0cmluZywgYW55PlxuICBwcm9maWxlOiBSZWNvcmQ8c3RyaW5nLCBhbnk+XG59KSB7XG4gIGNvbnN0IHsgZGVzY3JpcHRvciwgcHJvZmlsZSB9ID0gcHJvcHNcblxuICBjb25zdCBhanYgPSBuZXcgQWp2KClcbiAgY29uc3QgdmFsaWRhdGUgPSBhanYuY29tcGlsZShwcm9maWxlKVxuICB2YWxpZGF0ZShkZXNjcmlwdG9yKVxuICByZXR1cm4gdmFsaWRhdGUuZXJyb3JzID8/IFtdXG59XG4iXX0=

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

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

package/build/descriptor/validate.spec.js

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+import { validateDescriptor } from "./validate.js";
+describe("validateDescriptor", () => {
+    it("returns empty array for valid descriptor", async () => {
+        const profile = {
+            type: "object",
+            required: ["name", "version"],
+            properties: {
+                name: { type: "string" },
+                version: { type: "string" },
+                description: { type: "string" },
+            },
+        };
+        const descriptor = {
+            name: "test-package",
+            version: "1.0.0",
+            description: "A test package",
+        };
+        const result = await validateDescriptor({
+            descriptor,
+            profile,
+        });
+        expect(result).toEqual([]);
+    });
+    it("returns validation errors for invalid descriptor", async () => {
+        const profile = {
+            type: "object",
+            required: ["name", "version"],
+            properties: {
+                name: { type: "string" },
+                version: { type: "string" },
+                description: { type: "string" },
+            },
+        };
+        const descriptor = {
+            name: "test-package",
+            version: 123,
+            description: "A test package with wrong version type",
+        };
+        const result = await validateDescriptor({
+            descriptor,
+            profile,
+        });
+        expect(result).not.toBeNull();
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBeGreaterThan(0);
+        const error = result[0];
+        expect(error).toBeDefined();
+        if (error) {
+            expect(error.keyword).toBe("type");
+            expect(error.instancePath).toBe("/version");
+        }
+    });
+    it("returns errors when required fields are missing", async () => {
+        const profile = {
+            type: "object",
+            required: ["name", "version", "required_field"],
+            properties: {
+                name: { type: "string" },
+                version: { type: "string" },
+                required_field: { type: "string" },
+            },
+        };
+        const descriptor = {
+            name: "test-package",
+            version: "1.0.0",
+        };
+        const result = await validateDescriptor({
+            descriptor,
+            profile,
+        });
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBeGreaterThan(0);
+        const error = result[0];
+        expect(error).toBeDefined();
+        if (error) {
+            expect(error.keyword).toBe("required");
+            expect(error.params).toBeDefined();
+            if (error.params) {
+                expect(error.params.missingProperty).toBe("required_field");
+            }
+        }
+    });
+    it("validates nested objects in the descriptor", async () => {
+        const profile = {
+            type: "object",
+            required: ["name", "version", "author"],
+            properties: {
+                name: { type: "string" },
+                version: { type: "string" },
+                author: {
+                    type: "object",
+                    required: ["name", "email"],
+                    properties: {
+                        name: { type: "string" },
+                        email: {
+                            type: "string",
+                            pattern: "^[^@]+@[^@]+\\.[^@]+$",
+                        },
+                    },
+                },
+            },
+        };
+        const descriptor = {
+            name: "test-package",
+            version: "1.0.0",
+            author: {
+                name: "Test Author",
+                email: "invalid-email",
+            },
+        };
+        const result = await validateDescriptor({
+            descriptor,
+            profile,
+        });
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBeGreaterThan(0);
+        const hasEmailPatternError = result.some(error => error &&
+            error.instancePath === "/author/email" &&
+            error.keyword === "pattern");
+        expect(hasEmailPatternError).toBe(true);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate.spec.js","sourceRoot":"","sources":["../../descriptor/validate.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, expect, it } from \"vitest\"\nimport { validateDescriptor } from \"./validate.js\"\n\ndescribe(\"validateDescriptor\", () => {\n  it(\"returns empty array for valid descriptor\", async () => {\n    const profile = {\n      type: \"object\",\n      required: [\"name\", \"version\"],\n      properties: {\n        name: { type: \"string\" },\n        version: { type: \"string\" },\n        description: { type: \"string\" },\n      },\n    }\n\n    const descriptor = {\n      name: \"test-package\",\n      version: \"1.0.0\",\n      description: \"A test package\",\n    }\n\n    const result = await validateDescriptor({\n      descriptor,\n      profile,\n    })\n\n    expect(result).toEqual([])\n  })\n\n  it(\"returns validation errors for invalid descriptor\", async () => {\n    const profile = {\n      type: \"object\",\n      required: [\"name\", \"version\"],\n      properties: {\n        name: { type: \"string\" },\n        version: { type: \"string\" },\n        description: { type: \"string\" },\n      },\n    }\n\n    const descriptor = {\n      name: \"test-package\",\n      version: 123,\n      description: \"A test package with wrong version type\",\n    }\n\n    const result = await validateDescriptor({\n      descriptor,\n      profile,\n    })\n\n    expect(result).not.toBeNull()\n    expect(Array.isArray(result)).toBe(true)\n    expect(result.length).toBeGreaterThan(0)\n\n    const error = result[0]\n    expect(error).toBeDefined()\n    if (error) {\n      expect(error.keyword).toBe(\"type\")\n      expect(error.instancePath).toBe(\"/version\")\n    }\n  })\n\n  it(\"returns errors when required fields are missing\", async () => {\n    const profile = {\n      type: \"object\",\n      required: [\"name\", \"version\", \"required_field\"],\n      properties: {\n        name: { type: \"string\" },\n        version: { type: \"string\" },\n        required_field: { type: \"string\" },\n      },\n    }\n\n    const descriptor = {\n      name: \"test-package\",\n      version: \"1.0.0\",\n    }\n\n    const result = await validateDescriptor({\n      descriptor,\n      profile,\n    })\n\n    expect(Array.isArray(result)).toBe(true)\n    expect(result.length).toBeGreaterThan(0)\n\n    const error = result[0]\n    expect(error).toBeDefined()\n    if (error) {\n      expect(error.keyword).toBe(\"required\")\n      expect(error.params).toBeDefined()\n      if (error.params) {\n        expect(error.params.missingProperty).toBe(\"required_field\")\n      }\n    }\n  })\n\n  it(\"validates nested objects in the descriptor\", async () => {\n    const profile = {\n      type: \"object\",\n      required: [\"name\", \"version\", \"author\"],\n      properties: {\n        name: { type: \"string\" },\n        version: { type: \"string\" },\n        author: {\n          type: \"object\",\n          required: [\"name\", \"email\"],\n          properties: {\n            name: { type: \"string\" },\n            email: {\n              type: \"string\",\n              pattern: \"^[^@]+@[^@]+\\\\.[^@]+$\",\n            },\n          },\n        },\n      },\n    }\n\n    const descriptor = {\n      name: \"test-package\",\n      version: \"1.0.0\",\n      author: {\n        name: \"Test Author\",\n        email: \"invalid-email\",\n      },\n    }\n\n    const result = await validateDescriptor({\n      descriptor,\n      profile,\n    })\n\n    expect(Array.isArray(result)).toBe(true)\n    expect(result.length).toBeGreaterThan(0)\n\n    const hasEmailPatternError = result.some(\n      error =>\n        error &&\n        error.instancePath === \"/author/email\" &&\n        error.keyword === \"pattern\",\n    )\n\n    expect(hasEmailPatternError).toBe(true)\n  })\n})\n"]}

package/build/dialect/Dialect.d.ts

@@ -0,0 +1,88 @@
+/**
+ * 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 {
+    /**
+     * The name of this dialect
+     */
+    name?: string;
+    /**
+     * JSON schema profile URL for validation
+     */
+    $schema?: 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/index.d.ts

@@ -0,0 +1,3 @@
+export { validateDialect } from "./validate.js";
+export type { Dialect } from "./Dialect.js";
+export { loadDialect } from "./load.js";

package/build/dialect/index.js

@@ -0,0 +1,3 @@
+export { validateDialect } from "./validate.js";
+export { loadDialect } from "./load.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9kaWFsZWN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFFL0MsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLFdBQVcsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IHZhbGlkYXRlRGlhbGVjdCB9IGZyb20gXCIuL3ZhbGlkYXRlLmpzXCJcbmV4cG9ydCB0eXBlIHsgRGlhbGVjdCB9IGZyb20gXCIuL0RpYWxlY3QuanNcIlxuZXhwb3J0IHsgbG9hZERpYWxlY3QgfSBmcm9tIFwiLi9sb2FkLmpzXCJcbiJdfQ==

package/build/dialect/load.d.ts

@@ -0,0 +1,4 @@
+import type { Dialect } from "./Dialect.js";
+export declare function loadDialect(props: {
+    path: string;
+}): Promise<Dialect>;

package/build/dialect/load.js

@@ -0,0 +1,7 @@
+import { loadDescriptor } from "../descriptor/load.js";
+export async function loadDialect(props) {
+    const descriptor = await loadDescriptor(props);
+    // TODO: validate descriptor against schema
+    return descriptor;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2RpYWxlY3QvbG9hZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sdUJBQXVCLENBQUE7QUFHdEQsTUFBTSxDQUFDLEtBQUssVUFBVSxXQUFXLENBQUMsS0FBdUI7SUFDdkQsTUFBTSxVQUFVLEdBQUcsTUFBTSxjQUFjLENBQUMsS0FBSyxDQUFDLENBQUE7SUFDOUMsMkNBQTJDO0lBQzNDLE9BQU8sVUFBcUIsQ0FBQTtBQUM5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbG9hZERlc2NyaXB0b3IgfSBmcm9tIFwiLi4vZGVzY3JpcHRvci9sb2FkLmpzXCJcbmltcG9ydCB0eXBlIHsgRGlhbGVjdCB9IGZyb20gXCIuL0RpYWxlY3QuanNcIlxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gbG9hZERpYWxlY3QocHJvcHM6IHsgcGF0aDogc3RyaW5nIH0pIHtcbiAgY29uc3QgZGVzY3JpcHRvciA9IGF3YWl0IGxvYWREZXNjcmlwdG9yKHByb3BzKVxuICAvLyBUT0RPOiB2YWxpZGF0ZSBkZXNjcmlwdG9yIGFnYWluc3Qgc2NoZW1hXG4gIHJldHVybiBkZXNjcmlwdG9yIGFzIERpYWxlY3Rcbn1cbiJdfQ==