@static-pages/core 5.0.3 → 7.0.0-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,111 @@
+# CHANGELOG
+
+## 7.0.0-alpha.0
+- New `CreateReader` and `CreateWriter` utilities available as `from` and `to` prop values.
+- Writers now recieve an AsyncIterable as the previous method made too much confusion.
+- Type defintion improvements.
+- Test suite switched from tap to mocha for now.
+- Coverage reports switched from nyc to c8.
+
+
+## 6.0.0
+- Adopt JS iterator protocol for the writer callbacks.
+- Removed the `.teardown()` call on the writer when iteration finished. The iterator protocol gives better tools to express these logic.
+
+
+## 5.0.3
+- Updated .npmignore to remove unneeded files from package.
+
+## 5.0.2
+- Use Github Actions instead of Travis-CI, replace Build status badge.
+
+## 5.0.1
+- Updated maintenance badge in README.md.
+
+## 5.0.0
+- Added a `.teardown()` call on the writer which is executed when iteration finished.
+- Provided better type definitions.
+
+
+## 4.0.0
+- Now types are exported in a namespace.
+
+
+## 3.0.4
+- Updated eslint config.
+
+## 3.0.3
+- Added esm tests.
+- Improved build configuration.
+
+## 3.0.2
+- Improved examples.
+
+## 3.0.1
+- Updated docs.
+
+## 3.0.0
+- Removed `variables` option on `Route` type. You can use `.bind()` on the writer to achieve the same functionality.
+- Updated tests.
+- Updated README.md.
+
+
+## 2.1.0
+- In addition to the default export, now the main function also gets exported as `staticPages`.
+
+## 2.0.2
+- Updated dependencies.
+- Updated docker image link in README.md.
+
+## 2.0.1
+- Fixed a typo in README.md.
+
+## 2.0.0
+- Made configuration a bit cleaner and predictable by wrapping additional variables in a `variables` key in the `Route` type.
+- Updated tests.
+- Updated docs.
+- Changed some eslint configuration.
+
+
+## 1.0.4
+- Improved esmodule compatibility.
+- Simplified syntax of `Data` type.
+
+## 1.0.3
+- Made `isIterable` test a bit cleaner.
+
+## 1.0.2
+- Added eslint support.
+
+## 1.0.1
+- First stable release.
+- Added node12 support.
+- Updated .npmignore to remove unneeded files from package.
+- Updated dependencies.
+- Updated examples in README.md.
+- Added badges to README.md.
+
+
+## 0.1.6
+- Updated tests to get 100% coverage.
+- Added test cases when `staticPages()` should throw.
+- Fixed a faulty throws case.
+
+## 0.1.5
+- Added Travis testing and Coveralls coverage badge to README.md.
+
+## 0.1.4
+- Improved README.md.
+
+## 0.1.3
+- Added error handling which should throw when invalid params provided.
+
+## 0.1.2
+- Configured a `prepack` script to automatically test before publish.
+
+## 0.1.1
+- Updated .npmignore to omit /src folder from release.
+- Updated package keywords.
+
+## 0.1.0
+- Initial work in progress release.

package/README.md

@@ -1,68 +1,76 @@
 # Static Pages / Core
 
-[![Build Status](https://github.com/staticpagesjs/core/actions/workflows/coveralls.yaml/badge.svg)](https://github.com/staticpagesjs/core/actions/workflows/coveralls.yaml)
+[![Build Status](https://github.com/staticpagesjs/core/actions/workflows/build.yaml/badge.svg)](https://github.com/staticpagesjs/core/actions/workflows/build.yaml)
 [![Coverage Status](https://coveralls.io/repos/github/staticpagesjs/core/badge.svg?branch=master)](https://coveralls.io/github/staticpagesjs/core?branch=master)
 ![npms.io (quality)](https://img.shields.io/npms-io/quality-score/@static-pages/core?label=quality)
-![Maintenance](https://img.shields.io/maintenance/yes/2023)
-
-This package contains only the core; this means it does not provide CLI support or readers and writers.
-You can import this library to your JS project then add your own controllers, readers and writers.
+![Maintenance](https://img.shields.io/maintenance/yes/2024)
 
 Yet another static pages generator?
 Yes! Because I browsed the whole jamstack scene, but could not find one which
-1. uses MVC pattern
-2. can read input from any source (YAML, JSON, front-matter style markdowns, database etc.)
-3. can render with any template engine (Twig, ejs, Pug, Mustache etc.)
-4. supports incremental builds
-5. has a flexible CLI tool (see [@static-pages/cli](https://www.npmjs.com/package/@static-pages/cli) on npm)
-6. has a Docker image (see [staticpages/cli](https://hub.docker.com/repository/docker/staticpages/cli) on dockerhub)
-7. written in JS (preferably TypeScript)
-8. easy to extend with JS code
-9. learning and using is easy (Gatsby, Hugo, Jekyll, Eleventy etc. are so cool but harder to learn and configure)
+1. can read input from any source (YAML, JSON, front-matter style markdowns, database etc.)
+2. can render with any template engine (Twig, ejs, Pug, Mustache etc.)
+3. written in JS (preferably TypeScript)
+4. easy to extend with JS code
+5. supports incremental builds
+6. uses MVC pattern
+7. learning and using is easy (Gatsby, Hugo, Jekyll, Eleventy etc. are so cool but harder to learn and configure)
 
 And because I wrote a ton of custom static generators before; I tought I can improve the concepts to a point where its (hopefully) useful for others.
 
 ## Where should I use this?
-This project targets small and medium sized projects. The rendering process tries to be as fast as possible so its also useful when you need performance.
+
+This project targets small and medium sized websites. The rendering process tries to be as fast as possible so its also useful when you need performance.
 
 ## Documentation
-[Visit the project page.](https://staticpagesjs.github.io/)
+
+For detailed information, visit the [project page](https://staticpagesjs.github.io/).
 
 ## Usage
-__Readers__ provides an iterable list of page data. __Controllers__ can manipulate and extend each data object. __Writers__ render the final output for you.
 
 ```js
 import staticPages from '@static-pages/core';
-import markdownReader from '@static-pages/markdown-reader';
-import yamlReader from '@static-pages/yaml-reader';
-import twigWriter from '@static-pages/twig-writer';
-
-staticPages({
-    from: markdownReader({
-        pattern: "pages/**/*.md"
-    }),
-    to: twigWriter({
-        view: "content.html.twig",
-        viewsDir: "path/to/views/folder",
-        outDir: "path/to/output/folder",
-    }),
-    controller(data) {
-        data.timestamp = new Date().toJSON(); // adds a "timestamp" variable
-        return data; // returning the data is required if you want to send it to the renderer
-    }
-}, {
-    from: yamlReader({ // assume we have the home page data in yaml format.
-        pattern: "home/*.yaml" // <-- reads home/en.yaml, home/de.yaml, home/fr.yaml etc.
-    }),
-    to: twigWriter({
-        view: "home.html.twig",
-        viewsDir: "path/to/views/folder",
-        outDir: "path/to/output/folder",
-    }),
+import twig from '@static-pages/twig';
+
+// Default options for every `Route` via .with() call.
+const generate = staticPages.with({
+    to: {
+        render: twig({
+            viewsDir: 'path/to/views/folder'
+        }),
+    },
     controller(data) {
-        data.commitHash = yourGetCommitHashFn();
+        // adds a 'now' variable to the template context
+        data.now = new Date().toJSON();
+
+        // returning the data is required
         return data;
     }
+});
+
+// Generate every document type as a page.
+// One route equals one batch of similar pages.
+generate({
+    from: {
+        cwd: 'pages',
+        pattern: '**/*.md',
+    },
+}, {
+    // Any Iterable or AsyncIterable also accepted eg. an array
+    from: [
+        { title: 'About', url: 'about', body: 'About us content' },
+        { title: 'Privacy', url: 'privacy', body: 'Privacy content' },
+    ],
+}, {
+    from: {
+        cwd: 'home',
+        pattern: '*.yaml',
+    },
+    to: {
+        render: twig({
+            view: 'home.html.twig',
+            viewsDir: 'path/to/views/folder',
+        }),
+    },
 })
 .catch(error => {
     console.error('Error:', error);
@@ -70,25 +78,150 @@ staticPages({
 });
 ```
 
-## `staticPages(...routes: Route[])`
+### Notes
+
+> The `controller` may return with multiple documents, each will be rendered as a separate page. Alternatively it may return `undefined` to prevent the rendering of the current document.
+
+> The `from` parameter can also recieve an `Iterable` or an `AsyncIterable` type!
 
-Each route consists of a `from`, `to` and optionally a `controller` property matching the definition below.
+> The `to` parameter can also recieve a `function` that handles the document rendering and storing!
+
+
+## `staticPages(...routes: Route[]): Promise<void>`
+
+Each route consists of a `from`, `to` and a `controller` property matching the definition below.
 
 ```ts
-type Data = Record<string, unknown>;
-type Route = {
-    from: Iterable<Data> | AsyncIterable<Data>;
-    to: { (data: Data): void | Promise<void>; teardown?(): void | Promise<void>; };
-    controller?(data: Data): void | Data | Data[] | Promise<void | Data | Data[]>;
-};
+interface Route<F, T> {
+    from?: Iterable<F> | AsyncIterable<F> | CreateReaderOptions<F>;
+    to?: { (data: AsyncIterable<T>): MaybePromise<void>; } | CreateWriterOptions<T>;
+    controller?(data: F): MaybePromise<undefined | T | Iterable<T> | AsyncIterable<T>>;
+}
+
+type MaybePromise<T> = T | Promise<T>;
+
+interface CreateReaderOptions<T> {
+    // Handles file operations, defaults to nodejs `fs` module
+    fs?: Filesystem;
+    // Current working directory
+    cwd?: string;
+    // File patterns to include
+    pattern?: string | string[];
+    // File patterns to exclude
+    ignore?: string | string[];
+    // Callback to parse a file content into an object
+    parse?(content: Uint8Array | string, filename: string): MaybePromise<T>;
+    // Called on error
+    onError?(error: unknown): MaybePromise<void>;
+}
+
+interface CreateWriterOptions<T> {
+    // Handles file operations, defaults to nodejs `fs` module
+    fs?: Filesystem;
+    // Current working directory
+    cwd?: string;
+    // Callback that renders the document into a page
+    render?(data: T): MaybePromise<Uint8Array | string>;
+    // Callback that retrieves the filename (URL) of a page
+    name?(data: T): MaybePromise<string>;
+    // Called on error
+    onError?(error: unknown): MaybePromise<void>;
+}
+
+interface Stats {
+	isFile(): boolean;
+	isDirectory(): boolean;
+}
+
+interface Dirent {
+	name: string;
+	path: string;
+	isFile(): boolean;
+	isDirectory(): boolean;
+}
+
+interface Filesystem {
+	readdir(
+		path: string | URL,
+		options: {
+			encoding: 'utf8';
+			withFileTypes: false;
+			recursive: boolean;
+		},
+		callback: (err: Error | null, files: string[]) => void,
+	): void;
+
+	readdir(
+		path: string | URL,
+		options: {
+			encoding: 'utf8';
+			withFileTypes: true;
+			recursive: boolean;
+		},
+		callback: (err: Error | null, files: Dirent[]) => void,
+	): void;
+
+	readFile(
+		path: string | URL,
+		options: {
+			encoding: 'utf8';
+		},
+		callback: (err: Error | null, data: string) => void
+	): void;
+
+	readFile(
+		path: string | URL,
+		options: null,
+		callback: (err: Error | null, data: Uint8Array) => void
+	): void;
+
+	stat(
+		path: string | URL,
+		callback: (err: Error | null, stats: Stats) => void
+	): void;
+
+	mkdir(
+		path: string | URL,
+		options: {
+			recursive: true;
+		},
+		callback: (err: Error | null, path?: string) => void
+	): void;
+
+	writeFile(
+		path: string | URL,
+		data: string | Uint8Array,
+		callback: (err: Error | null) => void
+	): void;
+}
 ```
 
-> Tip: Controllers may return an array of `Data` objects; each will be rendered as a separate page.
-> Alternatively it may return `void` to prevent the rendering of the current data object.
+### `Filesystem` interface
+
+When you use the `createReader` and `createWriter` interfaces to read and write documents, you can provide a `Filesystem` implementation. This interface is a minimal subset of the [NodeJS FS API](https://nodejs.org/api/fs.html). By default we use the built-in `node:fs` module.
+
+### `CreateReaderOptions` default parameters
+- `fs`: the nodejs `fs` module
+- `cwd`: `'pages'`
+- `parse`: automatically parse `json`, `yaml`, `yml`, `md` or `markdown` extensions with `yaml` and `gray-matter` packages.
+- `onError`: `(err) => { throw err; }`
+
+### `CreateWriterOptions` default parameters
+- `fs`: the nodejs `fs` module
+- `cwd`: `'public'`
+- `name`: `(data) => data.url`
+- `render`: `(data) => data.content`
+- `onError`: `(err) => { throw err; }`
+
+
+## `staticPages.with(defaults: Partial<Route>): { (...routes: Partial<Route>[]): Promise<void>; }`
+
+Preconfigures a separate instance of the `staticPages` call with the given default parameters.
+These only works as fallback values, you can override every value later.
+
+If a `from` or `to` parameter is a plain object in both defaults and later at the route definition they will be merged (see usage example).
 
-> Tip: To schedule cleanup after writers you can define a `.teardown()` member on the writer call.
-> This callback will be run after the last page is processed. If more writers provide the same callback
-> its only executed once.
 
 ## Missing a feature?
-Create an issue describing your needs. If it fits the scope of the project I will implement it or you can implement it your own and submit a pull request.
+Create an issue describing your needs!
+If it fits the scope of the project I will implement it.

package/cjs/autoparse.d.ts

@@ -0,0 +1 @@
+export declare function autoparse(content: string | Uint8Array, filename: string): any;

package/cjs/autoparse.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoparse = void 0;
+const yaml_1 = require("yaml");
+const gray_matter_1 = __importDefault(require("gray-matter"));
+function autoparse(content, filename) {
+    const extension = filename.split('.').pop().toLowerCase();
+    switch (extension) {
+        case 'json':
+            return JSON.parse(content.toString());
+        case 'yaml':
+        case 'yml':
+            return (0, yaml_1.parse)(content.toString());
+        case 'md':
+        case 'markdown':
+            const { data, content: markdownContent } = (0, gray_matter_1.default)(content.toString());
+            return { ...data, content: markdownContent };
+    }
+    throw new Error(`Could not parse document with '${extension}' extension.`);
+}
+exports.autoparse = autoparse;

package/cjs/create-reader.d.ts

@@ -0,0 +1,15 @@
+import type { MaybePromise, Filesystem } from './helpers.js';
+export declare namespace createReader {
+    interface Options<T> {
+        fs?: Filesystem;
+        cwd?: string;
+        pattern?: string | string[];
+        ignore?: string | string[];
+        parse?(content: Uint8Array | string, filename: string): MaybePromise<T>;
+        onError?(error: unknown): MaybePromise<void>;
+    }
+}
+export declare function createReader<T>({ fs, cwd, pattern, ignore, parse, onError, }?: createReader.Options<T>): AsyncGenerator<Awaited<T>, void, unknown>;
+export declare namespace createReader {
+    var isOptions: <T>(x: unknown) => x is Options<T>;
+}

package/cjs/create-reader.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReader = void 0;
+const picomatch_1 = __importDefault(require("picomatch"));
+const autoparse_js_1 = require("./autoparse.js");
+const helpers_js_1 = require("./helpers.js");
+const node_path_1 = require("node:path");
+const node_fs_1 = __importDefault(require("node:fs"));
+async function* createReader({ fs = node_fs_1.default, cwd = 'pages', pattern, ignore, parse = autoparse_js_1.autoparse, onError = (error) => { throw error; }, } = {}) {
+    if (!(0, helpers_js_1.isFilesystem)(fs))
+        throw new TypeError(`Expected Node FS compatible implementation at 'fs' property.`);
+    if (typeof cwd !== 'string')
+        throw new TypeError(`Expected 'string', recieved '${(0, helpers_js_1.getType)(cwd)}' at 'cwd' property.`);
+    if (!cwd)
+        throw new TypeError(`Expected non-empty string at 'cwd'.`);
+    if (typeof pattern !== 'undefined' && typeof pattern !== 'string' && !Array.isArray(pattern))
+        throw new TypeError(`Expected 'string' or 'string[]', recieved '${(0, helpers_js_1.getType)(pattern)}' at 'pattern' property.`);
+    if (typeof ignore !== 'undefined' && typeof ignore !== 'string' && !Array.isArray(ignore))
+        throw new TypeError(`Expected 'string' or 'string[]', recieved '${(0, helpers_js_1.getType)(ignore)}' at 'ignore' property.`);
+    if (typeof parse !== 'function')
+        throw new TypeError(`Expected 'function', recieved '${(0, helpers_js_1.getType)(parse)}' at 'parse' property.`);
+    if (typeof onError !== 'function')
+        throw new TypeError(`Expected 'function', recieved '${(0, helpers_js_1.getType)(onError)}' at 'onError' property.`);
+    let filenames = await new Promise((resolve, reject) => {
+        fs.readdir(cwd, { encoding: 'utf8', recursive: true, withFileTypes: true }, (err, files) => {
+            if (err)
+                reject(err);
+            else
+                resolve(files
+                    .filter(x => x.isFile())
+                    .map(x => (0, node_path_1.join)((0, node_path_1.relative)(cwd, x.path), x.name)));
+        });
+    });
+    if (typeof pattern !== 'undefined' || typeof ignore !== 'undefined') {
+        const filteredFilenames = [];
+        const isMatch = (0, picomatch_1.default)(pattern !== null && pattern !== void 0 ? pattern : '**/*', { ignore });
+        for (const filename of filenames) {
+            if (isMatch(filename)) {
+                filteredFilenames.push(filename);
+            }
+        }
+        filenames = filteredFilenames;
+    }
+    for (const filename of filenames) {
+        try {
+            const content = await new Promise((resolve, reject) => {
+                fs.readFile((0, node_path_1.join)(cwd, filename), null, (err, data) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(data);
+                });
+            });
+            yield await parse(content, filename);
+        }
+        catch (error) {
+            await onError(error);
+        }
+    }
+}
+exports.createReader = createReader;
+createReader.isOptions = (x) => {
+    return x == undefined || (!!x && typeof x === 'object' && !(0, helpers_js_1.isIterable)(x) && !(0, helpers_js_1.isAsyncIterable)(x));
+};

package/cjs/create-writer.d.ts

@@ -0,0 +1,14 @@
+import type { MaybePromise, Filesystem } from './helpers.js';
+export declare namespace createWriter {
+    interface Options<T> {
+        fs?: Filesystem;
+        cwd?: string;
+        name?(data: T): MaybePromise<string>;
+        render?(data: T): MaybePromise<Uint8Array | string>;
+        onError?(error: unknown): MaybePromise<void>;
+    }
+}
+export declare function createWriter<T>({ fs, cwd, name, render, onError, }?: createWriter.Options<T>): (iterable: Iterable<T> | AsyncIterable<T>) => Promise<void>;
+export declare namespace createWriter {
+    var isOptions: <T>(x: unknown) => x is Options<T>;
+}

package/cjs/create-writer.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWriter = void 0;
+const helpers_js_1 = require("./helpers.js");
+const node_path_1 = require("node:path");
+const nodeFs = __importStar(require("node:fs"));
+const defaultNamer = (data) => {
+    if (!!data && typeof data === 'object' && 'url' in data && typeof data.url === 'string') {
+        return data.url.concat('.html');
+    }
+    throw new Error(`Missing 'url' field in the document.`);
+};
+const defaultRenderer = (data) => {
+    if (!!data && typeof data === 'object' && 'content' in data) {
+        return '' + data.content;
+    }
+    throw new Error(`Missing 'content' field in the document.`);
+};
+function createWriter({ fs = nodeFs, cwd = 'public', name = defaultNamer, render = defaultRenderer, onError = (error) => { throw error; }, } = {}) {
+    if (!(0, helpers_js_1.isFilesystem)(fs))
+        throw new TypeError(`Expected Node FS compatible implementation at 'fs' property.`);
+    if (typeof cwd !== 'string')
+        throw new TypeError(`Expected 'string', recieved '${(0, helpers_js_1.getType)(cwd)}' at 'cwd' property.`);
+    if (!cwd)
+        throw new TypeError(`Expected non-empty string at 'cwd'.`);
+    if (typeof render !== 'function')
+        throw new TypeError(`Expected 'function', recieved '${(0, helpers_js_1.getType)(render)}' at 'render' property.`);
+    if (typeof name !== 'function')
+        throw new TypeError(`Expected 'function', recieved '${(0, helpers_js_1.getType)(name)}' at 'name' property.`);
+    if (typeof onError !== 'function')
+        throw new TypeError(`Expected 'function', recieved '${(0, helpers_js_1.getType)(onError)}' at 'onError' property.`);
+    return async function (iterable) {
+        if (!(0, helpers_js_1.isIterable)(iterable) && !(0, helpers_js_1.isAsyncIterable)(iterable))
+            throw new TypeError(`Expected 'Iterable' or 'AsyncIterable' at callback.`);
+        for await (const data of iterable) {
+            try {
+                const filepath = cwd + '/' + await name(data);
+                const dirpath = (0, node_path_1.dirname)(filepath);
+                await new Promise((resolve, reject) => {
+                    fs.stat(dirpath, (err, stats) => {
+                        if (err) {
+                            fs.mkdir(dirpath, { recursive: true }, (err) => {
+                                if (err) {
+                                    reject(err);
+                                }
+                                else {
+                                    resolve(undefined);
+                                }
+                            });
+                        }
+                        else {
+                            resolve(undefined);
+                        }
+                    });
+                });
+                const content = await render(data);
+                await new Promise((resolve, reject) => {
+                    fs.writeFile(filepath, content, (err) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve(undefined);
+                    });
+                });
+            }
+            catch (error) {
+                await onError(error);
+            }
+        }
+    };
+}
+exports.createWriter = createWriter;
+createWriter.isOptions = (x) => {
+    return x == undefined || (!!x && typeof x === 'object');
+};

package/cjs/helpers.d.ts

@@ -0,0 +1,37 @@
+export type MaybePromise<T> = T | Promise<T>;
+interface Stats {
+    isFile(): boolean;
+    isDirectory(): boolean;
+}
+interface Dirent {
+    name: string;
+    path: string;
+    isFile(): boolean;
+    isDirectory(): boolean;
+}
+export interface Filesystem {
+    readdir(path: string | URL, options: {
+        encoding: 'utf8';
+        withFileTypes: false;
+        recursive: boolean;
+    }, callback: (err: Error | null, files: string[]) => void): void;
+    readdir(path: string | URL, options: {
+        encoding: 'utf8';
+        withFileTypes: true;
+        recursive: boolean;
+    }, callback: (err: Error | null, files: Dirent[]) => void): void;
+    readFile(path: string | URL, options: {
+        encoding: 'utf8';
+    }, callback: (err: Error | null, data: string) => void): void;
+    readFile(path: string | URL, options: null, callback: (err: Error | null, data: Uint8Array) => void): void;
+    stat(path: string | URL, callback: (err: Error | null, stats: Stats) => void): void;
+    mkdir(path: string | URL, options: {
+        recursive: true;
+    }, callback: (err: Error | null, path?: string) => void): void;
+    writeFile(path: string | URL, data: string | Uint8Array, callback: (err: Error | null) => void): void;
+}
+export declare const isFilesystem: (x: unknown) => x is Filesystem;
+export declare const isIterable: <T>(x: unknown) => x is Iterable<T>;
+export declare const isAsyncIterable: <T>(x: unknown) => x is AsyncIterable<T>;
+export declare const getType: (x: unknown) => string;
+export {};

package/cjs/helpers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getType = exports.isAsyncIterable = exports.isIterable = exports.isFilesystem = void 0;
+const isFilesystem = (x) => !!x && typeof x === 'object' && 'stat' in x && 'mkdir' in x && 'readFile' in x && 'writeFile' in x;
+exports.isFilesystem = isFilesystem;
+const isIterable = (x) => !!x && typeof x === 'object' && Symbol.iterator in x && typeof x[Symbol.iterator] === 'function';
+exports.isIterable = isIterable;
+const isAsyncIterable = (x) => !!x && typeof x === 'object' && Symbol.asyncIterator in x && typeof x[Symbol.asyncIterator] === 'function';
+exports.isAsyncIterable = isAsyncIterable;
+const getType = (x) => typeof x === 'object' ? (x ? (Array.isArray(x) ? 'array' : 'object') : 'null') : typeof x;
+exports.getType = getType;