@frictionless-ts/dataset 1.0.1

package/build/resource/save.js

@@ -0,0 +1,53 @@
+import { convertResourceToDescriptor, denormalizePath, getFilename, isRemotePath, } from "@frictionless-ts/metadata";
+import invariant from "tiny-invariant";
+export async function saveResourceFiles(resource, options) {
+    const { basepath, withRemote, withoutFolders } = options;
+    const descriptor = convertResourceToDescriptor(resource, { basepath });
+    const dedupIndexes = new Map();
+    const saveFile = async (path, name, index) => {
+        const isRemote = isRemotePath(path);
+        // Denormalized path always uses "/" as the path separator
+        let denormalizedPath = denormalizePath(path, { basepath });
+        const normalizedPath = path;
+        if (isRemote) {
+            if (!withRemote)
+                return path;
+            const filename = getFilename(path);
+            if (!filename)
+                return path;
+            denormalizedPath = filename;
+        }
+        else if (withoutFolders) {
+            denormalizedPath = denormalizedPath.replaceAll("/", "-");
+        }
+        const dedupIndex = dedupIndexes.get(denormalizedPath) ?? 0;
+        dedupIndexes.set(denormalizedPath, dedupIndex + 1);
+        if (dedupIndex) {
+            denormalizedPath = denormalizedPath.replace(/^(.*?)([^\/]+?)(\.[^\/]+(?:\.[^\/]+)*)$/, `$1$2-${dedupIndex}$3`);
+        }
+        denormalizedPath = await options.saveFile({
+            propertyName: name,
+            propertyIndex: index,
+            normalizedPath,
+            denormalizedPath,
+        });
+        return denormalizedPath;
+    };
+    if (typeof resource.path === "string") {
+        descriptor.path = await saveFile(resource.path, "path", 0);
+    }
+    if (Array.isArray(resource.path)) {
+        invariant(Array.isArray(descriptor.path), "Multipart as resource.path");
+        for (const [index, path] of resource.path.entries()) {
+            descriptor.path[index] = await saveFile(path, "path", index);
+        }
+    }
+    for (const name of ["dialect", "schema"]) {
+        const path = resource[name];
+        if (typeof path === "string") {
+            descriptor[name] = await saveFile(path, name, 0);
+        }
+    }
+    return descriptor;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/build/resource/save.spec.js

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import { saveResourceFiles } from "./save.js";
+describe("saveResourceFiles", () => {
+    it.each([
+        {
+            description: "local path",
+            basepath: "data",
+            resource: { path: "data/table.csv" },
+            descriptor: { path: "table.csv" },
+        },
+        {
+            description: "local paths",
+            basepath: "data",
+            resource: { path: ["data/table1.csv", "data/table2.csv"] },
+            descriptor: { path: ["table1.csv", "table2.csv"] },
+        },
+        {
+            description: "local path and remote path",
+            basepath: "data",
+            resource: {
+                path: "data/table.csv",
+                schema: "https://example.com/schema.json",
+            },
+            descriptor: {
+                path: "table.csv",
+                schema: "https://example.com/schema.json",
+            },
+        },
+        {
+            description: "local path and remote path using withRemote",
+            basepath: "data",
+            withRemote: true,
+            resource: {
+                type: "table",
+                path: "data/table.csv",
+                schema: "https://example.com/schema.json",
+            },
+            descriptor: {
+                type: "table",
+                path: "table.csv",
+                schema: "schema.json",
+            },
+        },
+        {
+            description: "remote paths with the same filename using withRemote",
+            basepath: "data",
+            withRemote: true,
+            resource: {
+                path: [
+                    "http://example1.com/table.csv",
+                    "http://example2.com/table.csv",
+                    "http://example3.com/table.csv",
+                    "http://example4.com/table.csv.zip",
+                    "http://example5.com/table.csv.zip",
+                ],
+            },
+            descriptor: {
+                path: [
+                    "table.csv",
+                    "table-1.csv",
+                    "table-2.csv",
+                    "table.csv.zip",
+                    "table-1.csv.zip",
+                ],
+            },
+        },
+        {
+            description: "local paths in different folders",
+            basepath: "data",
+            resource: {
+                type: "table",
+                path: "data/folder1/table.csv",
+                schema: "data/folder2/schema.json",
+            },
+            descriptor: {
+                type: "table",
+                path: "folder1/table.csv",
+                schema: "folder2/schema.json",
+            },
+        },
+        {
+            description: "local paths in different folders using withoutFolders",
+            basepath: "data",
+            withoutFolders: true,
+            resource: {
+                type: "table",
+                path: "data/folder1/table.csv",
+                schema: "data/folder2/schema.json",
+            },
+            descriptor: {
+                type: "table",
+                path: "folder1-table.csv",
+                schema: "folder2-schema.json",
+            },
+        },
+    ])("$description", async ({ resource, basepath, withRemote, withoutFolders, descriptor }) => {
+        expect(
+        // @ts-ignore
+        await saveResourceFiles(resource, {
+            basepath,
+            withRemote,
+            withoutFolders,
+            saveFile: async (props) => props.denormalizedPath,
+        })).toEqual(descriptor);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/stream/concat.d.ts

@@ -0,0 +1,3 @@
+import type { Readable } from "node:stream";
+import { default as Multistream } from "multistream";
+export declare function concatFileStreams(streams: Readable[]): Multistream;

package/build/stream/concat.js

@@ -0,0 +1,5 @@
+import { default as Multistream } from "multistream";
+export function concatFileStreams(streams) {
+    return new Multistream(streams);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uY2F0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3RyZWFtL2NvbmNhdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsT0FBTyxJQUFJLFdBQVcsRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUVwRCxNQUFNLFVBQVUsaUJBQWlCLENBQUMsT0FBbUI7SUFDbkQsT0FBTyxJQUFJLFdBQVcsQ0FBQyxPQUFPLENBQUMsQ0FBQTtBQUNqQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBSZWFkYWJsZSB9IGZyb20gXCJub2RlOnN0cmVhbVwiXG5pbXBvcnQgeyBkZWZhdWx0IGFzIE11bHRpc3RyZWFtIH0gZnJvbSBcIm11bHRpc3RyZWFtXCJcblxuZXhwb3J0IGZ1bmN0aW9uIGNvbmNhdEZpbGVTdHJlYW1zKHN0cmVhbXM6IFJlYWRhYmxlW10pIHtcbiAgcmV0dXJuIG5ldyBNdWx0aXN0cmVhbShzdHJlYW1zKVxufVxuIl19

package/build/stream/index.d.ts

@@ -0,0 +1,3 @@
+export { concatFileStreams } from "./concat.ts";
+export { loadFileStream } from "./load.ts";
+export { saveFileStream } from "./save.ts";

package/build/stream/index.js

@@ -0,0 +1,4 @@
+export { concatFileStreams } from "./concat.js";
+export { loadFileStream } from "./load.js";
+export { saveFileStream } from "./save.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zdHJlYW0vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sYUFBYSxDQUFBO0FBQy9DLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDMUMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLFdBQVcsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGNvbmNhdEZpbGVTdHJlYW1zIH0gZnJvbSBcIi4vY29uY2F0LnRzXCJcbmV4cG9ydCB7IGxvYWRGaWxlU3RyZWFtIH0gZnJvbSBcIi4vbG9hZC50c1wiXG5leHBvcnQgeyBzYXZlRmlsZVN0cmVhbSB9IGZyb20gXCIuL3NhdmUudHNcIlxuIl19

package/build/stream/load.d.ts

@@ -0,0 +1,5 @@
+import { Readable } from "node:stream";
+export declare function loadFileStream(path: string | string[], options?: {
+    index?: number;
+    maxBytes?: number;
+}): Promise<Readable | import("fs").ReadStream>;

package/build/stream/load.js

@@ -0,0 +1,46 @@
+import { createReadStream } from "node:fs";
+import { Readable, Transform } from "node:stream";
+import { isRemotePath } from "@frictionless-ts/metadata";
+export async function loadFileStream(path, options) {
+    const index = options?.index ?? 0;
+    const paths = Array.isArray(path) ? path : [path];
+    const indexPath = paths[index];
+    if (!indexPath) {
+        throw new Error(`Cannot stream resource ${indexPath} at index ${index}`);
+    }
+    const isRemote = isRemotePath(indexPath);
+    const stream = isRemote
+        ? await loadRemoteFileStream(indexPath, options)
+        : await loadLocalFileStream(indexPath, options);
+    return stream;
+}
+async function loadRemoteFileStream(path, options) {
+    const response = await fetch(path);
+    if (!response.body) {
+        throw new Error(`Cannot stream remote resource: ${path}`);
+    }
+    let stream = Readable.fromWeb(response.body);
+    if (options?.maxBytes) {
+        stream = limitBytesStream(stream, options.maxBytes);
+    }
+    return stream;
+}
+async function loadLocalFileStream(path, options) {
+    const end = options?.maxBytes ? options.maxBytes - 1 : undefined;
+    return createReadStream(path, { end });
+}
+function limitBytesStream(inputStream, maxBytes) {
+    let total = 0;
+    return inputStream.pipe(new Transform({
+        transform(chunk, _encoding, callback) {
+            if (total >= maxBytes) {
+                this.push(null);
+                callback();
+                return;
+            }
+            total += chunk.length;
+            callback(null, chunk);
+        },
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/stream/save.d.ts

@@ -0,0 +1,5 @@
+import type { Readable } from "node:stream";
+export declare function saveFileStream(stream: Readable, options: {
+    path: string;
+    overwrite?: boolean;
+}): Promise<void>;

package/build/stream/save.js

@@ -0,0 +1,13 @@
+import { createWriteStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { pipeline } from "node:stream/promises";
+export async function saveFileStream(stream, options) {
+    const { path, overwrite } = options;
+    // It is an equivalent to ensureDir function that won't overwrite an existing directory
+    await mkdir(dirname(path), { recursive: true });
+    await pipeline(stream, 
+    // The "wx" flag ensures that the file won't overwrite an existing file
+    createWriteStream(path, { flags: overwrite ? "w" : "wx" }));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2F2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3N0cmVhbS9zYXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLFNBQVMsQ0FBQTtBQUMzQyxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sa0JBQWtCLENBQUE7QUFDeEMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUVuQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sc0JBQXNCLENBQUE7QUFFL0MsTUFBTSxDQUFDLEtBQUssVUFBVSxjQUFjLENBQ2xDLE1BQWdCLEVBQ2hCLE9BR0M7SUFFRCxNQUFNLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxHQUFHLE9BQU8sQ0FBQTtJQUVuQyx1RkFBdUY7SUFDdkYsTUFBTSxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUE7SUFFL0MsTUFBTSxRQUFRLENBQ1osTUFBTTtJQUNOLHVFQUF1RTtJQUN2RSxpQkFBaUIsQ0FBQyxJQUFJLEVBQUUsRUFBRSxLQUFLLEVBQUUsU0FBUyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDLENBQzNELENBQUE7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY3JlYXRlV3JpdGVTdHJlYW0gfSBmcm9tIFwibm9kZTpmc1wiXG5pbXBvcnQgeyBta2RpciB9IGZyb20gXCJub2RlOmZzL3Byb21pc2VzXCJcbmltcG9ydCB7IGRpcm5hbWUgfSBmcm9tIFwibm9kZTpwYXRoXCJcbmltcG9ydCB0eXBlIHsgUmVhZGFibGUgfSBmcm9tIFwibm9kZTpzdHJlYW1cIlxuaW1wb3J0IHsgcGlwZWxpbmUgfSBmcm9tIFwibm9kZTpzdHJlYW0vcHJvbWlzZXNcIlxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gc2F2ZUZpbGVTdHJlYW0oXG4gIHN0cmVhbTogUmVhZGFibGUsXG4gIG9wdGlvbnM6IHtcbiAgICBwYXRoOiBzdHJpbmdcbiAgICBvdmVyd3JpdGU/OiBib29sZWFuXG4gIH0sXG4pIHtcbiAgY29uc3QgeyBwYXRoLCBvdmVyd3JpdGUgfSA9IG9wdGlvbnNcblxuICAvLyBJdCBpcyBhbiBlcXVpdmFsZW50IHRvIGVuc3VyZURpciBmdW5jdGlvbiB0aGF0IHdvbid0IG92ZXJ3cml0ZSBhbiBleGlzdGluZyBkaXJlY3RvcnlcbiAgYXdhaXQgbWtkaXIoZGlybmFtZShwYXRoKSwgeyByZWN1cnNpdmU6IHRydWUgfSlcblxuICBhd2FpdCBwaXBlbGluZShcbiAgICBzdHJlYW0sXG4gICAgLy8gVGhlIFwid3hcIiBmbGFnIGVuc3VyZXMgdGhhdCB0aGUgZmlsZSB3b24ndCBvdmVyd3JpdGUgYW4gZXhpc3RpbmcgZmlsZVxuICAgIGNyZWF0ZVdyaXRlU3RyZWFtKHBhdGgsIHsgZmxhZ3M6IG92ZXJ3cml0ZSA/IFwid1wiIDogXCJ3eFwiIH0pLFxuICApXG59XG4iXX0=

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@frictionless-ts/dataset",
+  "type": "module",
+  "version": "1.0.1",
+  "exports": "./build/index.js",
+  "sideEffects": false,
+  "files": [
+    "build"
+  ],
+  "license": "MIT",
+  "author": "Evgeny Karev",
+  "repository": "https://github.com/frictionlessdata/frictionless-ts",
+  "description": "Fast TypeScript data management framework built on top of the Data Package standard and Polars DataFrames",
+  "keywords": [
+    "frictionless",
+    "data",
+    "polars",
+    "dataframe",
+    "datapackage",
+    "tableschema",
+    "typescript",
+    "validation",
+    "quality",
+    "fair",
+    "dataset",
+    "ckan",
+    "datahub"
+  ],
+  "dependencies": {
+    "chardet": "^2.1.0",
+    "exit-hook": "^4.0.0",
+    "fflate": "^0.8.2",
+    "hasha": "^6.0.0",
+    "isbinaryfile": "^5.0.4",
+    "multistream": "^4.1.0",
+    "p-all": "^5.0.1",
+    "p-map": "^7.0.3",
+    "tempy": "3.1.0",
+    "tiny-invariant": "^1.3.3",
+    "@frictionless-ts/metadata": "1.0.1"
+  },
+  "devDependencies": {
+    "@types/multistream": "4.1.3"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}