livemark 0.2.0

package/build/dialect/save.d.ts

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

package/build/dialect/save.js

@@ -0,0 +1,13 @@
+import { saveDescriptor } from "../descriptor/save.js";
+/**
+ * Save a Dialect to a file path
+ * Works in Node.js environments
+ */
+export async function saveDialect(props) {
+    const { dialect, path } = props;
+    return saveDescriptor({
+        descriptor: dialect,
+        path,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2F2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2RpYWxlY3Qvc2F2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sdUJBQXVCLENBQUE7QUFHdEQ7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxXQUFXLENBQUMsS0FBeUM7SUFDekUsTUFBTSxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsR0FBRyxLQUFLLENBQUE7SUFFL0IsT0FBTyxjQUFjLENBQUM7UUFDcEIsVUFBVSxFQUFFLE9BQU87UUFDbkIsSUFBSTtLQUNMLENBQUMsQ0FBQTtBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzYXZlRGVzY3JpcHRvciB9IGZyb20gXCIuLi9kZXNjcmlwdG9yL3NhdmUuanNcIlxuaW1wb3J0IHR5cGUgeyBEaWFsZWN0IH0gZnJvbSBcIi4vRGlhbGVjdC5qc1wiXG5cbi8qKlxuICogU2F2ZSBhIERpYWxlY3QgdG8gYSBmaWxlIHBhdGhcbiAqIFdvcmtzIGluIE5vZGUuanMgZW52aXJvbm1lbnRzXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBzYXZlRGlhbGVjdChwcm9wczogeyBkaWFsZWN0OiBEaWFsZWN0OyBwYXRoOiBzdHJpbmcgfSkge1xuICBjb25zdCB7IGRpYWxlY3QsIHBhdGggfSA9IHByb3BzXG5cbiAgcmV0dXJuIHNhdmVEZXNjcmlwdG9yKHtcbiAgICBkZXNjcmlwdG9yOiBkaWFsZWN0LFxuICAgIHBhdGgsXG4gIH0pXG59XG4iXX0=

package/build/dialect/validate.d.ts

@@ -0,0 +1 @@
+export declare function validateDialect(dialect: string): Promise<string>;

package/build/dialect/validate.js

@@ -0,0 +1,4 @@
+export async function validateDialect(dialect) {
+    return dialect;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9kaWFsZWN0L3ZhbGlkYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxLQUFLLFVBQVUsZUFBZSxDQUFDLE9BQWU7SUFDbkQsT0FBTyxPQUFPLENBQUE7QUFDaEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBhc3luYyBmdW5jdGlvbiB2YWxpZGF0ZURpYWxlY3QoZGlhbGVjdDogc3RyaW5nKSB7XG4gIHJldHVybiBkaWFsZWN0XG59XG4iXX0=

package/build/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./dialect/index.js";
+export * from "./package/index.js";
+export * from "./resource/index.js";
+export * from "./schema/index.js";

package/build/index.js

@@ -0,0 +1,5 @@
+export * from "./dialect/index.js";
+export * from "./package/index.js";
+export * from "./resource/index.js";
+export * from "./schema/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFBO0FBQ2xDLGNBQWMsb0JBQW9CLENBQUE7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQTtBQUNuQyxjQUFjLG1CQUFtQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vZGlhbGVjdC9pbmRleC5qc1wiXG5leHBvcnQgKiBmcm9tIFwiLi9wYWNrYWdlL2luZGV4LmpzXCJcbmV4cG9ydCAqIGZyb20gXCIuL3Jlc291cmNlL2luZGV4LmpzXCJcbmV4cG9ydCAqIGZyb20gXCIuL3NjaGVtYS9pbmRleC5qc1wiXG4iXX0=

package/build/metadata/index.d.ts

@@ -0,0 +1,3 @@
+export { loadMetadata } from "./load.js";
+export { saveMetadata } from "./save.js";
+export { validateMetadata } from "./validate.js";

package/build/metadata/index.js

@@ -0,0 +1,4 @@
+export { loadMetadata } from "./load.js";
+export { saveMetadata } from "./save.js";
+export { validateMetadata } from "./validate.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9tZXRhZGF0YS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ3hDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDeEMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sZUFBZSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgbG9hZE1ldGFkYXRhIH0gZnJvbSBcIi4vbG9hZC5qc1wiXG5leHBvcnQgeyBzYXZlTWV0YWRhdGEgfSBmcm9tIFwiLi9zYXZlLmpzXCJcbmV4cG9ydCB7IHZhbGlkYXRlTWV0YWRhdGEgfSBmcm9tIFwiLi92YWxpZGF0ZS5qc1wiXG4iXX0=

package/build/metadata/load.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Load a metadata (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
+ *
+ * @param props Object containing the path to the metadata
+ */
+export declare function loadMetadata(props: {
+    path: string;
+}): Promise<Record<string, any>>;

package/build/metadata/load.js

@@ -0,0 +1,55 @@
+/**
+ * Load a metadata (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
+ *
+ * @param props Object containing the path to the metadata
+ */
+export async function loadMetadata(props) {
+    const { path } = props;
+    let isUrl = false;
+    try {
+        new URL(path);
+        isUrl = true;
+    }
+    catch {
+        isUrl = false;
+    }
+    return isUrl
+        ? await loadRemoteMetadata(props)
+        : await loadLocalMetadata(props);
+}
+/**
+ * Load a metadata (JSON Object) from a remote URL
+ * Supports HTTP, HTTPS, FTP, and FTPS protocols
+ *
+ * @param props Object containing the remote URL path
+ */
+async function loadRemoteMetadata(props) {
+    const { path } = props;
+    const url = new URL(path);
+    const protocol = url.protocol.toLowerCase();
+    if (!["http:", "https:", "ftp:", "ftps:"].includes(protocol)) {
+        throw new Error(`Unsupported URL protocol: ${protocol}`);
+    }
+    const response = await fetch(path);
+    if (!response.ok) {
+        throw new Error(`Failed to load metadata from URL: ${path}, status: ${response.status}`);
+    }
+    const data = (await response.json());
+    return data;
+}
+/**
+ * Load a metadata (JSON Object) from a local file
+ * Works in Node.js environments only
+ *
+ * @param props Object containing the file path
+ */
+async function loadLocalMetadata(props) {
+    const { path } = props;
+    const fs = await import("node:fs/promises");
+    await fs.access(path, fs.constants.R_OK);
+    const content = await fs.readFile(path, "utf-8");
+    return JSON.parse(content);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/metadata/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/metadata/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL21ldGFkYXRhL25vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLEtBQUssVUFBVSxZQUFZO0lBQ2hDLElBQUksVUFBVSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ3ZCLE1BQU0sRUFBRSxHQUFHLE1BQU0sTUFBTSxDQUFDLGtCQUFrQixDQUFDLENBQUE7UUFDM0MsTUFBTSxJQUFJLEdBQUcsTUFBTSxNQUFNLENBQUMsV0FBVyxDQUFDLENBQUE7UUFDdEMsT0FBTyxFQUFFLEVBQUUsRUFBRSxJQUFJLEVBQUUsQ0FBQTtJQUNyQixDQUFDO0lBRUQsT0FBTyxTQUFTLENBQUE7QUFDbEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBhc3luYyBmdW5jdGlvbiBsb2FkTm9kZUFwaXMoKSB7XG4gIGlmIChnbG9iYWxUaGlzLnByb2Nlc3MpIHtcbiAgICBjb25zdCBmcyA9IGF3YWl0IGltcG9ydChcIm5vZGU6ZnMvcHJvbWlzZXNcIilcbiAgICBjb25zdCBwYXRoID0gYXdhaXQgaW1wb3J0KFwibm9kZTpwYXRoXCIpXG4gICAgcmV0dXJuIHsgZnMsIHBhdGggfVxuICB9XG5cbiAgcmV0dXJuIHVuZGVmaW5lZFxufVxuIl19

package/build/metadata/save.d.ts

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

package/build/metadata/save.js

@@ -0,0 +1,17 @@
+import { loadNodeApis } from "./node.js";
+/**
+ * Save a metadata (JSON Object) to a file path
+ * Works in Node.js environments
+ */
+export async function saveMetadata(props) {
+    const { metadata, path } = props;
+    const node = await loadNodeApis();
+    if (!node) {
+        throw new Error("File system operations are not supported in this environment");
+    }
+    const content = JSON.stringify(metadata, 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2F2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL21ldGFkYXRhL3NhdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUV4Qzs7O0dBR0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLFlBQVksQ0FBQyxLQUdsQztJQUNDLE1BQU0sRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLEdBQUcsS0FBSyxDQUFBO0lBRWhDLE1BQU0sSUFBSSxHQUFHLE1BQU0sWUFBWSxFQUFFLENBQUE7SUFDakMsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ1YsTUFBTSxJQUFJLEtBQUssQ0FDYiw4REFBOEQsQ0FDL0QsQ0FBQTtJQUNILENBQUM7SUFFRCxNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUE7SUFFakQsTUFBTSxJQUFJLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFBO0lBQ2pFLE1BQU0sSUFBSSxDQUFDLEVBQUUsQ0FBQyxTQUFTLENBQUMsSUFBSSxFQUFFLE9BQU8sRUFBRSxPQUFPLENBQUMsQ0FBQTtJQUUvQyxPQUFPLElBQUksQ0FBQTtBQUNiLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBsb2FkTm9kZUFwaXMgfSBmcm9tIFwiLi9ub2RlLmpzXCJcblxuLyoqXG4gKiBTYXZlIGEgbWV0YWRhdGEgKEpTT04gT2JqZWN0KSB0byBhIGZpbGUgcGF0aFxuICogV29ya3MgaW4gTm9kZS5qcyBlbnZpcm9ubWVudHNcbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHNhdmVNZXRhZGF0YShwcm9wczoge1xuICBtZXRhZGF0YTogUmVjb3JkPHN0cmluZywgYW55PlxuICBwYXRoOiBzdHJpbmdcbn0pIHtcbiAgY29uc3QgeyBtZXRhZGF0YSwgcGF0aCB9ID0gcHJvcHNcblxuICBjb25zdCBub2RlID0gYXdhaXQgbG9hZE5vZGVBcGlzKClcbiAgaWYgKCFub2RlKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgXCJGaWxlIHN5c3RlbSBvcGVyYXRpb25zIGFyZSBub3Qgc3VwcG9ydGVkIGluIHRoaXMgZW52aXJvbm1lbnRcIixcbiAgICApXG4gIH1cblxuICBjb25zdCBjb250ZW50ID0gSlNPTi5zdHJpbmdpZnkobWV0YWRhdGEsIG51bGwsIDIpXG5cbiAgYXdhaXQgbm9kZS5mcy5ta2Rpcihub2RlLnBhdGguZGlybmFtZShwYXRoKSwgeyByZWN1cnNpdmU6IHRydWUgfSlcbiAgYXdhaXQgbm9kZS5mcy53cml0ZUZpbGUocGF0aCwgY29udGVudCwgXCJ1dGYtOFwiKVxuXG4gIHJldHVybiB0cnVlXG59XG4iXX0=

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

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

package/build/metadata/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 { saveMetadata } from "./save.js";
+describe("saveMetadata", () => {
+    const testMetadata = {
+        name: "test-metadata",
+        version: "1.0.0",
+        description: "Test metadata for save function",
+        resources: [
+            {
+                name: "resource1",
+                path: "data/resource1.csv",
+            },
+        ],
+    };
+    let testDir;
+    let testPath;
+    beforeEach(() => {
+        testDir = temporaryDirectory();
+        testPath = path.join(testDir, "metadata.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 metadata to the specified path", async () => {
+        const result = await saveMetadata({
+            metadata: testMetadata,
+            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(testMetadata);
+    });
+    it("should save a metadata to a nested directory path", async () => {
+        const nestedPath = path.join(testDir, "nested", "dir", "metadata.json");
+        const result = await saveMetadata({
+            metadata: testMetadata,
+            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(testMetadata);
+    });
+    it("should use pretty formatting with 2-space indentation", async () => {
+        await saveMetadata({
+            metadata: testMetadata,
+            path: testPath,
+        });
+        const content = await fs.readFile(testPath, "utf-8");
+        const expectedFormat = JSON.stringify(testMetadata, 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/metadata/validate.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Validate a metadata (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 validateMetadata(props: {
+    metadata: Record<string, any>;
+    profile: Record<string, any>;
+}): Promise<import("ajv").ErrorObject<string, Record<string, any>, unknown>[]>;

package/build/metadata/validate.js

@@ -0,0 +1,14 @@
+import { Ajv } from "ajv";
+/**
+ * Validate a metadata (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 validateMetadata(props) {
+    const { metadata, profile } = props;
+    const ajv = new Ajv();
+    const validate = ajv.compile(profile);
+    validate(metadata);
+    return validate.errors ?? [];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9tZXRhZGF0YS92YWxpZGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sS0FBSyxDQUFBO0FBRXpCOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLGdCQUFnQixDQUFDLEtBR3RDO0lBQ0MsTUFBTSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsR0FBRyxLQUFLLENBQUE7SUFFbkMsTUFBTSxHQUFHLEdBQUcsSUFBSSxHQUFHLEVBQUUsQ0FBQTtJQUNyQixNQUFNLFFBQVEsR0FBRyxHQUFHLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFBO0lBQ3JDLFFBQVEsQ0FBQyxRQUFRLENBQUMsQ0FBQTtJQUNsQixPQUFPLFFBQVEsQ0FBQyxNQUFNLElBQUksRUFBRSxDQUFBO0FBQzlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBanYgfSBmcm9tIFwiYWp2XCJcblxuLyoqXG4gKiBWYWxpZGF0ZSBhIG1ldGFkYXRhIChKU09OIE9iamVjdCkgYWdhaW5zdCBhIEpTT04gU2NoZW1hXG4gKiBJdCB1c2VzIEFqdiBmb3IgSlNPTiBTY2hlbWEgdmFsaWRhdGlvbiB1bmRlciB0aGUgaG9vZFxuICogSXQgcmV0dXJucyBhIGxpc3Qgb2YgZXJyb3JzIChlbXB0eSBpZiB2YWxpZClcbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHZhbGlkYXRlTWV0YWRhdGEocHJvcHM6IHtcbiAgbWV0YWRhdGE6IFJlY29yZDxzdHJpbmcsIGFueT5cbiAgcHJvZmlsZTogUmVjb3JkPHN0cmluZywgYW55PlxufSkge1xuICBjb25zdCB7IG1ldGFkYXRhLCBwcm9maWxlIH0gPSBwcm9wc1xuXG4gIGNvbnN0IGFqdiA9IG5ldyBBanYoKVxuICBjb25zdCB2YWxpZGF0ZSA9IGFqdi5jb21waWxlKHByb2ZpbGUpXG4gIHZhbGlkYXRlKG1ldGFkYXRhKVxuICByZXR1cm4gdmFsaWRhdGUuZXJyb3JzID8/IFtdXG59XG4iXX0=

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

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

package/build/metadata/validate.spec.js

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+import { validateMetadata } from "./validate.js";
+describe("validateMetadata", () => {
+    it("returns empty array for valid metadata", async () => {
+        const profile = {
+            type: "object",
+            required: ["name", "version"],
+            properties: {
+                name: { type: "string" },
+                version: { type: "string" },
+                description: { type: "string" },
+            },
+        };
+        const metadata = {
+            name: "test-package",
+            version: "1.0.0",
+            description: "A test package",
+        };
+        const result = await validateMetadata({
+            metadata,
+            profile,
+        });
+        expect(result).toEqual([]);
+    });
+    it("returns validation errors for invalid metadata", async () => {
+        const profile = {
+            type: "object",
+            required: ["name", "version"],
+            properties: {
+                name: { type: "string" },
+                version: { type: "string" },
+                description: { type: "string" },
+            },
+        };
+        const metadata = {
+            name: "test-package",
+            version: 123,
+            description: "A test package with wrong version type",
+        };
+        const result = await validateMetadata({
+            metadata,
+            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 metadata = {
+            name: "test-package",
+            version: "1.0.0",
+        };
+        const result = await validateMetadata({
+            metadata,
+            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 metadata", 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 metadata = {
+            name: "test-package",
+            version: "1.0.0",
+            author: {
+                name: "Test Author",
+                email: "invalid-email",
+            },
+        };
+        const result = await validateMetadata({
+            metadata,
+            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":["../../metadata/validate.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, expect, it } from \"vitest\"\nimport { validateMetadata } from \"./validate.js\"\n\ndescribe(\"validateMetadata\", () => {\n  it(\"returns empty array for valid metadata\", 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 metadata = {\n      name: \"test-package\",\n      version: \"1.0.0\",\n      description: \"A test package\",\n    }\n\n    const result = await validateMetadata({\n      metadata,\n      profile,\n    })\n\n    expect(result).toEqual([])\n  })\n\n  it(\"returns validation errors for invalid metadata\", 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 metadata = {\n      name: \"test-package\",\n      version: 123,\n      description: \"A test package with wrong version type\",\n    }\n\n    const result = await validateMetadata({\n      metadata,\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 metadata = {\n      name: \"test-package\",\n      version: \"1.0.0\",\n    }\n\n    const result = await validateMetadata({\n      metadata,\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 metadata\", 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 metadata = {\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 validateMetadata({\n      metadata,\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/package/Contributor.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Contributor information
+ */
+export interface Contributor {
+    /**
+     * Full name of the contributor
+     */
+    title: string;
+    /**
+     * Email address of the contributor
+     */
+    email?: string;
+    /**
+     * Path to relevant contributor information
+     */
+    path?: string;
+    /**
+     * Role of the contributor
+     */
+    role?: string;
+}

package/build/package/Contributor.js

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