@static-pages/core 6.0.0 → 7.0.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 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.

package/README.md

@@ -1,70 +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);
@@ -72,24 +78,150 @@ staticPages({
 });
 ```
 
-## `staticPages(...routes: Route[])`
+### Notes
 
-Each route consists of a `from`, `to` and optionally a `controller` property matching the definition below.
+> 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!
+
+> 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: IteratorResult<Data>): 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;
+}
 ```
 
-### Implementation Notes
+### `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.
 
-- The `controller` 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.
+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).
 
-- The writer function provided in the `to` property is expected to conform to the JavaScript iterator protocol in order to work. Specifically, this means that the function will be invoked with a `{ value: Data }` parameter for each data object, and will receive a `{ done: true }` parameter when it has finished processing the data and there is no more pages to write.
 
 ## 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), (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,34 @@
+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;
+    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;
+    readFile(path: string | URL, callback: (err: Error | null, data: Uint8Array) => 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;

package/cjs/index.d.ts

@@ -1,15 +1,4 @@
-export declare namespace staticPages {
-    type Route<R extends Record<string, unknown> = Record<string, unknown>, W extends Record<string, unknown> = Record<string, unknown>> = {
-        from: Iterable<R> | AsyncIterable<R>;
-        to(data: IteratorResult<W>): void | Promise<void>;
-        controller?(data: R): void | W | W[] | Promise<void | W | W[]>;
-    };
-}
-export declare function staticPages<R1 extends Record<string, unknown> = Record<string, unknown>, W1 extends Record<string, unknown> = Record<string, unknown>>(...routes: [staticPages.Route<R1, W1>]): Promise<void>;
-export declare function staticPages<R1 extends Record<string, unknown> = Record<string, unknown>, W1 extends Record<string, unknown> = Record<string, unknown>, R2 extends Record<string, unknown> = Record<string, unknown>, W2 extends Record<string, unknown> = Record<string, unknown>>(...routes: [staticPages.Route<R1, W1>, staticPages.Route<R2, W2>]): Promise<void>;
-export declare function staticPages<R1 extends Record<string, unknown> = Record<string, unknown>, W1 extends Record<string, unknown> = Record<string, unknown>, R2 extends Record<string, unknown> = Record<string, unknown>, W2 extends Record<string, unknown> = Record<string, unknown>, R3 extends Record<string, unknown> = Record<string, unknown>, W3 extends Record<string, unknown> = Record<string, unknown>>(...routes: [staticPages.Route<R1, W1>, staticPages.Route<R2, W2>, staticPages.Route<R3, W3>]): Promise<void>;
-export declare function staticPages<R1 extends Record<string, unknown> = Record<string, unknown>, W1 extends Record<string, unknown> = Record<string, unknown>, R2 extends Record<string, unknown> = Record<string, unknown>, W2 extends Record<string, unknown> = Record<string, unknown>, R3 extends Record<string, unknown> = Record<string, unknown>, W3 extends Record<string, unknown> = Record<string, unknown>, R4 extends Record<string, unknown> = Record<string, unknown>, W4 extends Record<string, unknown> = Record<string, unknown>>(...routes: [staticPages.Route<R1, W1>, staticPages.Route<R2, W2>, staticPages.Route<R3, W3>, staticPages.Route<R4, W4>]): Promise<void>;
-export declare function staticPages<R1 extends Record<string, unknown> = Record<string, unknown>, W1 extends Record<string, unknown> = Record<string, unknown>, R2 extends Record<string, unknown> = Record<string, unknown>, W2 extends Record<string, unknown> = Record<string, unknown>, R3 extends Record<string, unknown> = Record<string, unknown>, W3 extends Record<string, unknown> = Record<string, unknown>, R4 extends Record<string, unknown> = Record<string, unknown>, W4 extends Record<string, unknown> = Record<string, unknown>, R5 extends Record<string, unknown> = Record<string, unknown>, W5 extends Record<string, unknown> = Record<string, unknown>>(...routes: [staticPages.Route<R1, W1>, staticPages.Route<R2, W2>, staticPages.Route<R3, W3>, staticPages.Route<R4, W4>, staticPages.Route<R5, W5>]): Promise<void>;
-export declare function staticPages<R1 extends Record<string, unknown> = Record<string, unknown>, W1 extends Record<string, unknown> = Record<string, unknown>, R2 extends Record<string, unknown> = Record<string, unknown>, W2 extends Record<string, unknown> = Record<string, unknown>, R3 extends Record<string, unknown> = Record<string, unknown>, W3 extends Record<string, unknown> = Record<string, unknown>, R4 extends Record<string, unknown> = Record<string, unknown>, W4 extends Record<string, unknown> = Record<string, unknown>, R5 extends Record<string, unknown> = Record<string, unknown>, W5 extends Record<string, unknown> = Record<string, unknown>, R6 extends Record<string, unknown> = Record<string, unknown>, W6 extends Record<string, unknown> = Record<string, unknown>>(...routes: [staticPages.Route<R1, W1>, staticPages.Route<R2, W2>, staticPages.Route<R3, W3>, staticPages.Route<R4, W4>, staticPages.Route<R5, W5>, staticPages.Route<R6, W6>]): Promise<void>;
-export declare function staticPages(...routes: staticPages.Route[]): Promise<void>;
-export default staticPages;
+export { staticPages, staticPages as default } from './static-pages.js';
+export { createReader } from './create-reader.js';
+export { createWriter } from './create-writer.js';
+export type { Filesystem } from './helpers.js';

package/cjs/index.js

@@ -1,36 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.staticPages = void 0;
-const getType = (x) => typeof x === 'object' ? (x ? 'object' : 'null') : typeof x;
-const isIterable = (x) => typeof (x === null || x === void 0 ? void 0 : x[Symbol.iterator]) === 'function';
-const isAsyncIterable = (x) => typeof (x === null || x === void 0 ? void 0 : x[Symbol.asyncIterator]) === 'function';
-async function staticPages(...routes) {
-    for (const route of routes) {
-        if (typeof route !== 'object' || !route)
-            throw new Error(`Argument type mismatch, expected 'object', got '${getType(route)}'.`);
-        const { from, to, controller } = route;
-        if (!isIterable(from) && !isAsyncIterable(from))
-            throw new Error('Argument type mismatch, \'from\' exptects \'iterable\' or \'asyncIterable\'.');
-        if (typeof to !== 'function')
-            throw new Error(`Argument type mismatch, 'to' expects 'function', got '${getType(to)}'.`);
-        if (typeof controller !== 'undefined' && typeof controller !== 'function')
-            throw new Error(`Argument type mismatch, 'controller' expects 'function', got '${getType(controller)}'.`);
-        const isController = typeof controller === 'function';
-        for await (const data of from) {
-            const results = isController ? await controller(data) : data;
-            if (typeof results === 'object' && results) {
-                if (Array.isArray(results)) {
-                    for (const result of results) {
-                        await to({ value: result });
-                    }
-                }
-                else {
-                    await to({ value: results });
-                }
-            }
-        }
-        await to({ done: true, value: undefined });
-    }
-}
-exports.staticPages = staticPages;
-exports.default = staticPages;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWriter = exports.createReader = exports.default = exports.staticPages = void 0;
+var static_pages_js_1 = require("./static-pages.js");
+Object.defineProperty(exports, "staticPages", { enumerable: true, get: function () { return static_pages_js_1.staticPages; } });
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return static_pages_js_1.staticPages; } });
+var create_reader_js_1 = require("./create-reader.js");
+Object.defineProperty(exports, "createReader", { enumerable: true, get: function () { return create_reader_js_1.createReader; } });
+var create_writer_js_1 = require("./create-writer.js");
+Object.defineProperty(exports, "createWriter", { enumerable: true, get: function () { return create_writer_js_1.createWriter; } });