npm - @static-pages/core - Versions diffs - 7.0.0-alpha.5 → 7.0.0-alpha.6 - Mend

@static-pages/core 7.0.0-alpha.5 → 7.0.0-alpha.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

package/CHANGELOG.md CHANGED Viewed

@@ -1,7 +1,6 @@
 # CHANGELOG
 ## 7.0.0
-- New `CreateReader` and `CreateWriter` utilities available as `route.from` and `route.to` prop values.
 - Reverted `route.to` callbacks to work as it was in `v4.0.0`. The function is called per doucument, recieving the current page data.
 - Type defintion improvements.
 - Test suite switched from tap to mocha for now.

package/README.md CHANGED Viewed

@@ -17,60 +17,48 @@ Yes! Because I browsed the whole jamstack scene, but could not find one which
 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.
+This project is structured as a toolkit, published under the [@static-pages](https://www.npmjs.com/search?q=%40static-pages) namespace on NPM.
+In most cases you should not use this core package directly, but the [@static-pages/starter](https://www.npmjs.com/package/@static-pages/starter) is a good point to begin with.
 ## Where should I use this?
 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
-For detailed information, visit the [project page](https://staticpagesjs.github.io/).
 ## Usage
 ```js
+import fs from 'node:fs';
+import path from 'node:path';
 import staticPages from '@static-pages/core';
-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'
-        }),
-    },
+staticPages({
+    from: [
+        { title: 'About', url: 'about', content: 'About us content' },
+        { title: 'Privacy', url: 'privacy', content: 'Privacy content' },
+    ],
     controller(data) {
-        // 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',
     },
+    to({ title, url, content, now }) {
+        const fileName = path.join('public', url + '.html');
+        fs.mkdirSync(path.dirname(fileName), { recursive: true });
+        fs.writeFileSync(fileName, `<html><body><h1>${title}</h1><p>${content}</p><p>generated: ${now}</p></body></html>`);
+    }
 }, {
-    // 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',
-        }),
+    from: fs.readdir('pages', { recursive: true })
+        .map(x => JSON.parse(fs.readFileSync(path.join('pages', x), 'utf8'))),
+    controller({ title, url, content }) {
+        return {
+            url: url,
+            content: `<html><body><h1>${title}</h1><p>${content}</p><p>generated: ${new Date().toJSON()}</p></body></html>`,
+        };
     },
+    to({ url, content }) {
+        const fileName = path.join('public', url + '.html');
+        fs.mkdirSync(path.dirname(fileName), { recursive: true });
+        fs.writeFileSync(fileName, content);
+    }
 })
 .catch(error => {
     console.error('Error:', error);
@@ -82,125 +70,24 @@ generate({
 > 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 usage example above does a rough presentation only and not considered to be a production ready snippet. Helpers to read and write documents are provided in separate packages, eg. [@static-pages/io](https://www.npmjs.com/package/@static-pages/io).
-> The `to` parameter can also recieve a `function` that handles the document rendering and storing!
+## Documentation
+For detailed information, visit the [project page](https://staticpagesjs.github.io/).
-## `staticPages(...routes: Route[]): Promise<void>`
+### `staticPages(...routes: Route[]): Promise<void>`
 Each route consists of a `from`, `to` and a `controller` property matching the definition below.
 ```ts
 interface Route<F, T> {
-    from?: Iterable<F> | AsyncIterable<F> | createReader.Options<F>;
-    to?: { (data: T): MaybePromise<void>; } | createWriter.Options<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 Filesystem {
-	stat(
-		path: string | URL,
-		callback: (err: Error | null, stats: { isFile(): boolean; isDirectory(): boolean; }) => void
-	): void;
-	readdir(
-		path: string | URL,
-		options: {
-			encoding: 'utf8';
-			withFileTypes: false;
-			recursive: boolean;
-		},
-		callback: (err: Error | null, files: string[]) => 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;
+    from: Iterable<F> | AsyncIterable<F>;
+    to(data: T): void | Promise<void>;
+    controller?(data: F): undefined | T | Iterable<T> | AsyncIterable<T> | Promise<undefined | T | Iterable<T> | AsyncIterable<T>>;
 }
 ```
-### `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`: *see About the default `parse` function*
-- `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; }`
-### About the default `parse` function
-When using the default parser, a file type will be guessed by the file extension.
-These could be `json`, `yaml`, `yml`, `md` or `markdown`.
-- `json` will be parsed with `JSON.parse`
-- `yaml` and `yml` will be parsed with the `yaml` package
-- `md` and `markdown` will be parsed with the `gray-matter` package
-When the document does not contain an `url` property, this function will create one containing the filename without extension.
-## `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).
 ## Missing a feature?
 Create an issue describing your needs!
 If it fits the scope of the project I will implement it.

package/cjs/index.d.ts CHANGED Viewed

@@ -1,4 +1,13 @@
-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';
+export interface Route<F = unknown, T = unknown> {
+    from: Iterable<F> | AsyncIterable<F>;
+    to(data: T): void | Promise<void>;
+    controller?(data: F): undefined | T | Iterable<T> | AsyncIterable<T> | Promise<undefined | T | Iterable<T> | AsyncIterable<T>>;
+}
+export declare function staticPages<F1, T1>(...route: [Route<F1, T1>]): Promise<void>;
+export declare function staticPages<F1, T1, F2, T2>(...route: [Route<F1, T1>, Route<F2, T2>]): Promise<void>;
+export declare function staticPages<F1, T1, F2, T2, F3, T3>(...route: [Route<F1, T1>, Route<F2, T2>, Route<F3, T3>]): Promise<void>;
+export declare function staticPages<F1, T1, F2, T2, F3, T3, F4, T4>(...route: [Route<F1, T1>, Route<F2, T2>, Route<F3, T3>, Route<F4, T4>]): Promise<void>;
+export declare function staticPages<F1, T1, F2, T2, F3, T3, F4, T4, F5, T5>(...route: [Route<F1, T1>, Route<F2, T2>, Route<F3, T3>, Route<F4, T4>, Route<F5, T5>]): Promise<void>;
+export declare function staticPages<F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6>(...route: [Route<F1, T1>, Route<F2, T2>, Route<F3, T3>, Route<F4, T4>, Route<F5, T5>, Route<F6, T6>]): Promise<void>;
+export declare function staticPages(...routes: Route[]): Promise<void>;
+export default staticPages;

package/cjs/index.js CHANGED Viewed

@@ -1,10 +1,32 @@
 "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; } });
+exports.staticPages = void 0;
+const isIterable = (x) => !!x && typeof x === 'object' && Symbol.iterator in x && typeof x[Symbol.iterator] === 'function';
+const isAsyncIterable = (x) => !!x && typeof x === 'object' && Symbol.asyncIterator in x && typeof x[Symbol.asyncIterator] === 'function';
+const getType = (x) => typeof x === 'object' ? (x ? (Array.isArray(x) ? 'array' : 'object') : 'null') : typeof x;
+async function staticPages(...routes) {
+    for (const route of routes) {
+        if (typeof route !== 'object' || !route)
+            throw new TypeError(`Expected 'object', recieved '${getType(route)}'.`);
+        let { from, to, controller } = route;
+        if (!isIterable(from) && !isAsyncIterable(from))
+            throw new TypeError(`Expected 'Iterable' or 'AsyncIterable' at 'from' property.`);
+        if (typeof to !== 'function')
+            throw new TypeError(`Expected 'function', recieved '${getType(to)}' at 'to' property.`);
+        if (typeof controller !== 'undefined' && typeof controller !== 'function')
+            throw new TypeError(`Expected 'function', recieved '${getType(controller)}' at 'controller' property.`);
+        for await (const item of from) {
+            const data = controller ? await controller(item) : item;
+            if (isIterable(data) || isAsyncIterable(data)) {
+                for await (const item of data) {
+                    await to(item);
+                }
+            }
+            else if (typeof data !== 'undefined') {
+                await to(data);
+            }
+        }
+    }
+}
+exports.staticPages = staticPages;
+exports.default = staticPages;

package/esm/index.d.ts CHANGED Viewed

@@ -1,4 +1,13 @@
-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';
+export interface Route<F = unknown, T = unknown> {
+    from: Iterable<F> | AsyncIterable<F>;
+    to(data: T): void | Promise<void>;
+    controller?(data: F): undefined | T | Iterable<T> | AsyncIterable<T> | Promise<undefined | T | Iterable<T> | AsyncIterable<T>>;
+}
+export declare function staticPages<F1, T1>(...route: [Route<F1, T1>]): Promise<void>;
+export declare function staticPages<F1, T1, F2, T2>(...route: [Route<F1, T1>, Route<F2, T2>]): Promise<void>;
+export declare function staticPages<F1, T1, F2, T2, F3, T3>(...route: [Route<F1, T1>, Route<F2, T2>, Route<F3, T3>]): Promise<void>;
+export declare function staticPages<F1, T1, F2, T2, F3, T3, F4, T4>(...route: [Route<F1, T1>, Route<F2, T2>, Route<F3, T3>, Route<F4, T4>]): Promise<void>;
+export declare function staticPages<F1, T1, F2, T2, F3, T3, F4, T4, F5, T5>(...route: [Route<F1, T1>, Route<F2, T2>, Route<F3, T3>, Route<F4, T4>, Route<F5, T5>]): Promise<void>;
+export declare function staticPages<F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6>(...route: [Route<F1, T1>, Route<F2, T2>, Route<F3, T3>, Route<F4, T4>, Route<F5, T5>, Route<F6, T6>]): Promise<void>;
+export declare function staticPages(...routes: Route[]): Promise<void>;
+export default staticPages;

package/esm/index.js CHANGED Viewed

@@ -1,3 +1,28 @@
-export { staticPages, staticPages as default } from './static-pages.js';
-export { createReader } from './create-reader.js';
-export { createWriter } from './create-writer.js';
+const isIterable = (x) => !!x && typeof x === 'object' && Symbol.iterator in x && typeof x[Symbol.iterator] === 'function';
+const isAsyncIterable = (x) => !!x && typeof x === 'object' && Symbol.asyncIterator in x && typeof x[Symbol.asyncIterator] === 'function';
+const getType = (x) => typeof x === 'object' ? (x ? (Array.isArray(x) ? 'array' : 'object') : 'null') : typeof x;
+export async function staticPages(...routes) {
+    for (const route of routes) {
+        if (typeof route !== 'object' || !route)
+            throw new TypeError(`Expected 'object', recieved '${getType(route)}'.`);
+        let { from, to, controller } = route;
+        if (!isIterable(from) && !isAsyncIterable(from))
+            throw new TypeError(`Expected 'Iterable' or 'AsyncIterable' at 'from' property.`);
+        if (typeof to !== 'function')
+            throw new TypeError(`Expected 'function', recieved '${getType(to)}' at 'to' property.`);
+        if (typeof controller !== 'undefined' && typeof controller !== 'function')
+            throw new TypeError(`Expected 'function', recieved '${getType(controller)}' at 'controller' property.`);
+        for await (const item of from) {
+            const data = controller ? await controller(item) : item;
+            if (isIterable(data) || isAsyncIterable(data)) {
+                for await (const item of data) {
+                    await to(item);
+                }
+            }
+            else if (typeof data !== 'undefined') {
+                await to(data);
+            }
+        }
+    }
+}
+export default staticPages;

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@static-pages/core",
-  "version": "7.0.0-alpha.5",
+  "version": "7.0.0-alpha.6",
   "description": "General purpose static pages renderer.",
   "type": "module",
   "main": "cjs/index.js",
@@ -29,20 +29,13 @@
     "test": "mocha",
     "coverage": "c8 -r text -r text-summary -r lcov --include \"esm/*\" npm test"
   },
-  "dependencies": {
-    "gray-matter": "^4.0.3",
-    "yaml": "^2.3.4"
-  },
   "devDependencies": {
-    "@types/micromatch": "^4.0.4",
     "@types/node": "^20.10.5",
-    "@types/picomatch": "^2.3.2",
     "@typescript-eslint/eslint-plugin": "^6.15.0",
     "@typescript-eslint/parser": "^6.15.0",
     "c8": "^8.0.0",
     "eslint": "^8.1.0",
     "mocha": "^10.2.0",
-    "picomatch": "^3.0.1",
     "rimraf": "^5.0.1",
     "typescript": "^5.1.6"
   },

package/cjs/autoparse.d.ts DELETED Viewed

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

package/cjs/autoparse.js DELETED Viewed

@@ -1,37 +0,0 @@
-"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 dot = filename.lastIndexOf('.');
-    if (dot < 1) {
-        throw new Error(`Could not parse document without an extension.`);
-    }
-    const extension = filename.substring(filename.lastIndexOf('.') + 1).toLowerCase();
-    let doc;
-    switch (extension) {
-        case 'json':
-            doc = JSON.parse(content.toString());
-            break;
-        case 'yaml':
-        case 'yml':
-            doc = (0, yaml_1.parse)(content.toString());
-            break;
-        case 'md':
-        case 'markdown':
-            const { data, content: markdownContent } = (0, gray_matter_1.default)(content.toString());
-            doc = { ...data, content: markdownContent };
-            break;
-        default:
-            throw new Error(`Could not parse document with '${extension}' extension.`);
-    }
-    if (doc && typeof doc === 'object' && !('url' in doc)) {
-        doc.url = filename.substring(0, dot).replace(/\\/g, '/');
-    }
-    return doc;
-}
-exports.autoparse = autoparse;

package/cjs/create-reader.d.ts DELETED Viewed

@@ -1,15 +0,0 @@
-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 DELETED Viewed

@@ -1,76 +0,0 @@
-"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_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, { recursive: true, withFileTypes: false, encoding: 'utf8' }, (err, entries) => {
-            if (err)
-                return reject(err);
-            let filtered = [];
-            let processed = 0;
-            for (const entry of entries) {
-                fs.stat(cwd + '/' + entry, (err, stats) => {
-                    if (err)
-                        return reject(err);
-                    if (stats.isFile()) {
-                        filtered.push(entry);
-                    }
-                    if (++processed === entries.length) {
-                        return resolve(filtered);
-                    }
-                });
-            }
-        });
-    });
-    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(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 DELETED Viewed

@@ -1,14 +0,0 @@
-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>): (data: T) => Promise<void>;
-export declare namespace createWriter {
-    var isOptions: <T>(x: unknown) => x is Options<T>;
-}

package/cjs/create-writer.js DELETED Viewed

@@ -1,94 +0,0 @@
-"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 nodeFs = __importStar(require("node:fs"));
-const node_path_1 = require("node:path");
-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 (data) {
-        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 DELETED Viewed

@@ -1,21 +0,0 @@
-export type MaybePromise<T> = T | Promise<T>;
-export interface Filesystem {
-    stat(path: string | URL, callback: (err: Error | null, stats: {
-        isFile(): boolean;
-        isDirectory(): boolean;
-    }) => void): void;
-    readdir(path: string | URL, options: {
-        encoding: 'utf8';
-        withFileTypes: false;
-        recursive: boolean;
-    }, callback: (err: Error | null, files: string[]) => 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;

package/cjs/helpers.js DELETED Viewed

@@ -1,11 +0,0 @@
-"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/static-pages.d.ts DELETED Viewed

@@ -1,54 +0,0 @@
-import type { MaybePromise } from './helpers.js';
-import { createReader } from './create-reader.js';
-import { createWriter } from './create-writer.js';
-export declare namespace staticPages {
-    interface Route<F = unknown, T = unknown> {
-        from?: Iterable<F> | AsyncIterable<F> | createReader.Options<F>;
-        to?: {
-            (data: T): MaybePromise<void>;
-        } | createWriter.Options<T>;
-        controller?(data: F): MaybePromise<undefined | T | Iterable<T> | AsyncIterable<T>>;
-    }
-}
-export declare function staticPages<F1, T1>(...route: [
-    staticPages.Route<F1, T1>
-]): Promise<void>;
-export declare function staticPages<F1, T1, F2, T2>(...route: [
-    staticPages.Route<F1, T1>,
-    staticPages.Route<F2, T2>
-]): Promise<void>;
-export declare function staticPages<F1, T1, F2, T2, F3, T3>(...route: [
-    staticPages.Route<F1, T1>,
-    staticPages.Route<F2, T2>,
-    staticPages.Route<F3, T3>
-]): Promise<void>;
-export declare function staticPages<F1, T1, F2, T2, F3, T3, F4, T4>(...route: [
-    staticPages.Route<F1, T1>,
-    staticPages.Route<F2, T2>,
-    staticPages.Route<F3, T3>,
-    staticPages.Route<F4, T4>
-]): Promise<void>;
-export declare function staticPages<F1, T1, F2, T2, F3, T3, F4, T4, F5, T5>(...route: [
-    staticPages.Route<F1, T1>,
-    staticPages.Route<F2, T2>,
-    staticPages.Route<F3, T3>,
-    staticPages.Route<F4, T4>,
-    staticPages.Route<F5, T5>
-]): Promise<void>;
-export declare function staticPages<F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6>(...route: [
-    staticPages.Route<F1, T1>,
-    staticPages.Route<F2, T2>,
-    staticPages.Route<F3, T3>,
-    staticPages.Route<F4, T4>,
-    staticPages.Route<F5, T5>,
-    staticPages.Route<F6, T6>
-]): Promise<void>;
-export declare function staticPages(...routes: staticPages.Route[]): Promise<void>;
-export declare namespace staticPages {
-    var _a: ({ from, to, controller }: NullablePartialRoute) => typeof staticPages;
-    export { _a as with };
-}
-type NullablePartialRoute = {
-    [P in keyof staticPages.Route]?: null | staticPages.Route[P];
-};
-export {};

package/cjs/static-pages.js DELETED Viewed

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.staticPages = void 0;
-const helpers_js_1 = require("./helpers.js");
-const create_reader_js_1 = require("./create-reader.js");
-const create_writer_js_1 = require("./create-writer.js");
-async function staticPages(...routes) {
-    for (const route of routes) {
-        if (typeof route !== 'object' || !route)
-            throw new TypeError(`Expected 'object', recieved '${(0, helpers_js_1.getType)(route)}'.`);
-        let { from, to, controller } = route;
-        if (create_reader_js_1.createReader.isOptions(from))
-            from = (0, create_reader_js_1.createReader)(from);
-        if (create_writer_js_1.createWriter.isOptions(to))
-            to = (0, create_writer_js_1.createWriter)(to);
-        if (!(0, helpers_js_1.isIterable)(from) && !(0, helpers_js_1.isAsyncIterable)(from))
-            throw new TypeError(`Expected 'Iterable' or 'AsyncIterable' at 'from' property.`);
-        if (typeof to !== 'function')
-            throw new TypeError(`Expected 'function', recieved '${(0, helpers_js_1.getType)(to)}' at 'to' property.`);
-        if (typeof controller !== 'undefined' && typeof controller !== 'function')
-            throw new TypeError(`Expected 'function', recieved '${(0, helpers_js_1.getType)(controller)}' at 'controller' property.`);
-        for await (const data of from) {
-            const finalData = controller ? await controller(data) : data;
-            if ((0, helpers_js_1.isIterable)(finalData) || (0, helpers_js_1.isAsyncIterable)(finalData)) {
-                for await (const finalDataItem of finalData) {
-                    await to(finalDataItem);
-                }
-            }
-            else if (typeof finalData !== 'undefined') {
-                await to(finalData);
-            }
-        }
-    }
-}
-exports.staticPages = staticPages;
-staticPages.with = ({ from, to, controller }) => {
-    const withFunction = (newValue) => staticPages.with({
-        from: determineFrom(from, newValue.from),
-        to: determineTo(to, newValue.to),
-        controller: typeof newValue.controller !== 'undefined' ? newValue.controller : controller,
-    });
-    function modifiedStaticPages(...routes) {
-        return staticPages(...routes.map(route => {
-            var _a;
-            return ({
-                from: determineFrom(from, route.from),
-                to: determineTo(to, route.to),
-                controller: (_a = (typeof route.controller !== 'undefined' ? route.controller : controller)) !== null && _a !== void 0 ? _a : undefined,
-            });
-        }));
-    }
-    modifiedStaticPages.with = withFunction;
-    return modifiedStaticPages;
-};
-function determineFrom(oldValue, newValue) {
-    if (newValue && typeof newValue === 'object' && !(0, helpers_js_1.isIterable)(newValue) && !(0, helpers_js_1.isAsyncIterable)(newValue) &&
-        oldValue && typeof oldValue === 'object' && !(0, helpers_js_1.isIterable)(oldValue) && !(0, helpers_js_1.isAsyncIterable)(oldValue))
-        return { ...oldValue, ...newValue };
-    return typeof newValue !== 'undefined' ? newValue : oldValue;
-}
-function determineTo(oldValue, newValue) {
-    if (newValue && typeof newValue === 'object' &&
-        oldValue && typeof oldValue === 'object')
-        return { ...oldValue, ...newValue };
-    return typeof newValue !== 'undefined' ? newValue : oldValue;
-}

package/esm/autoparse.d.ts DELETED Viewed

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

package/esm/autoparse.js DELETED Viewed

@@ -1,30 +0,0 @@
-import { parse as parseYAML } from 'yaml';
-import parseMarkdown from 'gray-matter';
-export function autoparse(content, filename) {
-    const dot = filename.lastIndexOf('.');
-    if (dot < 1) {
-        throw new Error(`Could not parse document without an extension.`);
-    }
-    const extension = filename.substring(filename.lastIndexOf('.') + 1).toLowerCase();
-    let doc;
-    switch (extension) {
-        case 'json':
-            doc = JSON.parse(content.toString());
-            break;
-        case 'yaml':
-        case 'yml':
-            doc = parseYAML(content.toString());
-            break;
-        case 'md':
-        case 'markdown':
-            const { data, content: markdownContent } = parseMarkdown(content.toString());
-            doc = { ...data, content: markdownContent };
-            break;
-        default:
-            throw new Error(`Could not parse document with '${extension}' extension.`);
-    }
-    if (doc && typeof doc === 'object' && !('url' in doc)) {
-        doc.url = filename.substring(0, dot).replace(/\\/g, '/');
-    }
-    return doc;
-}

package/esm/create-reader.d.ts DELETED Viewed

@@ -1,15 +0,0 @@
-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/esm/create-reader.js DELETED Viewed

@@ -1,69 +0,0 @@
-import picomatch from 'picomatch';
-import { autoparse } from './autoparse.js';
-import { getType, isIterable, isAsyncIterable, isFilesystem } from './helpers.js';
-import nodeFs from 'node:fs';
-export async function* createReader({ fs = nodeFs, cwd = 'pages', pattern, ignore, parse = autoparse, onError = (error) => { throw error; }, } = {}) {
-    if (!isFilesystem(fs))
-        throw new TypeError(`Expected Node FS compatible implementation at 'fs' property.`);
-    if (typeof cwd !== 'string')
-        throw new TypeError(`Expected 'string', recieved '${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 '${getType(pattern)}' at 'pattern' property.`);
-    if (typeof ignore !== 'undefined' && typeof ignore !== 'string' && !Array.isArray(ignore))
-        throw new TypeError(`Expected 'string' or 'string[]', recieved '${getType(ignore)}' at 'ignore' property.`);
-    if (typeof parse !== 'function')
-        throw new TypeError(`Expected 'function', recieved '${getType(parse)}' at 'parse' property.`);
-    if (typeof onError !== 'function')
-        throw new TypeError(`Expected 'function', recieved '${getType(onError)}' at 'onError' property.`);
-    let filenames = await new Promise((resolve, reject) => {
-        fs.readdir(cwd, { recursive: true, withFileTypes: false, encoding: 'utf8' }, (err, entries) => {
-            if (err)
-                return reject(err);
-            let filtered = [];
-            let processed = 0;
-            for (const entry of entries) {
-                fs.stat(cwd + '/' + entry, (err, stats) => {
-                    if (err)
-                        return reject(err);
-                    if (stats.isFile()) {
-                        filtered.push(entry);
-                    }
-                    if (++processed === entries.length) {
-                        return resolve(filtered);
-                    }
-                });
-            }
-        });
-    });
-    if (typeof pattern !== 'undefined' || typeof ignore !== 'undefined') {
-        const filteredFilenames = [];
-        const isMatch = picomatch(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(cwd + '/' + filename, (err, data) => {
-                    if (err)
-                        reject(err);
-                    else
-                        resolve(data);
-                });
-            });
-            yield await parse(content, filename);
-        }
-        catch (error) {
-            await onError(error);
-        }
-    }
-}
-createReader.isOptions = (x) => {
-    return x == undefined || (!!x && typeof x === 'object' && !isIterable(x) && !isAsyncIterable(x));
-};

package/esm/create-writer.d.ts DELETED Viewed

@@ -1,14 +0,0 @@
-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>): (data: T) => Promise<void>;
-export declare namespace createWriter {
-    var isOptions: <T>(x: unknown) => x is Options<T>;
-}

package/esm/create-writer.js DELETED Viewed

@@ -1,67 +0,0 @@
-import { getType, isFilesystem } from './helpers.js';
-import * as nodeFs from 'node:fs';
-import { dirname } from 'node:path';
-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.`);
-};
-export function createWriter({ fs = nodeFs, cwd = 'public', name = defaultNamer, render = defaultRenderer, onError = (error) => { throw error; }, } = {}) {
-    if (!isFilesystem(fs))
-        throw new TypeError(`Expected Node FS compatible implementation at 'fs' property.`);
-    if (typeof cwd !== 'string')
-        throw new TypeError(`Expected 'string', recieved '${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 '${getType(render)}' at 'render' property.`);
-    if (typeof name !== 'function')
-        throw new TypeError(`Expected 'function', recieved '${getType(name)}' at 'name' property.`);
-    if (typeof onError !== 'function')
-        throw new TypeError(`Expected 'function', recieved '${getType(onError)}' at 'onError' property.`);
-    return async function (data) {
-        try {
-            const filepath = cwd + '/' + await name(data);
-            const dirpath = 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);
-        }
-    };
-}
-createWriter.isOptions = (x) => {
-    return x == undefined || (!!x && typeof x === 'object');
-};

package/esm/helpers.d.ts DELETED Viewed

@@ -1,21 +0,0 @@
-export type MaybePromise<T> = T | Promise<T>;
-export interface Filesystem {
-    stat(path: string | URL, callback: (err: Error | null, stats: {
-        isFile(): boolean;
-        isDirectory(): boolean;
-    }) => void): void;
-    readdir(path: string | URL, options: {
-        encoding: 'utf8';
-        withFileTypes: false;
-        recursive: boolean;
-    }, callback: (err: Error | null, files: string[]) => 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;

package/esm/helpers.js DELETED Viewed

@@ -1,4 +0,0 @@
-export const isFilesystem = (x) => !!x && typeof x === 'object' && 'stat' in x && 'mkdir' in x && 'readFile' in x && 'writeFile' in x;
-export const isIterable = (x) => !!x && typeof x === 'object' && Symbol.iterator in x && typeof x[Symbol.iterator] === 'function';
-export const isAsyncIterable = (x) => !!x && typeof x === 'object' && Symbol.asyncIterator in x && typeof x[Symbol.asyncIterator] === 'function';
-export const getType = (x) => typeof x === 'object' ? (x ? (Array.isArray(x) ? 'array' : 'object') : 'null') : typeof x;

package/esm/static-pages.d.ts DELETED Viewed

@@ -1,54 +0,0 @@
-import type { MaybePromise } from './helpers.js';
-import { createReader } from './create-reader.js';
-import { createWriter } from './create-writer.js';
-export declare namespace staticPages {
-    interface Route<F = unknown, T = unknown> {
-        from?: Iterable<F> | AsyncIterable<F> | createReader.Options<F>;
-        to?: {
-            (data: T): MaybePromise<void>;
-        } | createWriter.Options<T>;
-        controller?(data: F): MaybePromise<undefined | T | Iterable<T> | AsyncIterable<T>>;
-    }
-}
-export declare function staticPages<F1, T1>(...route: [
-    staticPages.Route<F1, T1>
-]): Promise<void>;
-export declare function staticPages<F1, T1, F2, T2>(...route: [
-    staticPages.Route<F1, T1>,
-    staticPages.Route<F2, T2>
-]): Promise<void>;
-export declare function staticPages<F1, T1, F2, T2, F3, T3>(...route: [
-    staticPages.Route<F1, T1>,
-    staticPages.Route<F2, T2>,
-    staticPages.Route<F3, T3>
-]): Promise<void>;
-export declare function staticPages<F1, T1, F2, T2, F3, T3, F4, T4>(...route: [
-    staticPages.Route<F1, T1>,
-    staticPages.Route<F2, T2>,
-    staticPages.Route<F3, T3>,
-    staticPages.Route<F4, T4>
-]): Promise<void>;
-export declare function staticPages<F1, T1, F2, T2, F3, T3, F4, T4, F5, T5>(...route: [
-    staticPages.Route<F1, T1>,
-    staticPages.Route<F2, T2>,
-    staticPages.Route<F3, T3>,
-    staticPages.Route<F4, T4>,
-    staticPages.Route<F5, T5>
-]): Promise<void>;
-export declare function staticPages<F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6>(...route: [
-    staticPages.Route<F1, T1>,
-    staticPages.Route<F2, T2>,
-    staticPages.Route<F3, T3>,
-    staticPages.Route<F4, T4>,
-    staticPages.Route<F5, T5>,
-    staticPages.Route<F6, T6>
-]): Promise<void>;
-export declare function staticPages(...routes: staticPages.Route[]): Promise<void>;
-export declare namespace staticPages {
-    var _a: ({ from, to, controller }: NullablePartialRoute) => typeof staticPages;
-    export { _a as with };
-}
-type NullablePartialRoute = {
-    [P in keyof staticPages.Route]?: null | staticPages.Route[P];
-};
-export {};

package/esm/static-pages.js DELETED Viewed

@@ -1,62 +0,0 @@
-import { getType, isIterable, isAsyncIterable } from './helpers.js';
-import { createReader } from './create-reader.js';
-import { createWriter } from './create-writer.js';
-export async function staticPages(...routes) {
-    for (const route of routes) {
-        if (typeof route !== 'object' || !route)
-            throw new TypeError(`Expected 'object', recieved '${getType(route)}'.`);
-        let { from, to, controller } = route;
-        if (createReader.isOptions(from))
-            from = createReader(from);
-        if (createWriter.isOptions(to))
-            to = createWriter(to);
-        if (!isIterable(from) && !isAsyncIterable(from))
-            throw new TypeError(`Expected 'Iterable' or 'AsyncIterable' at 'from' property.`);
-        if (typeof to !== 'function')
-            throw new TypeError(`Expected 'function', recieved '${getType(to)}' at 'to' property.`);
-        if (typeof controller !== 'undefined' && typeof controller !== 'function')
-            throw new TypeError(`Expected 'function', recieved '${getType(controller)}' at 'controller' property.`);
-        for await (const data of from) {
-            const finalData = controller ? await controller(data) : data;
-            if (isIterable(finalData) || isAsyncIterable(finalData)) {
-                for await (const finalDataItem of finalData) {
-                    await to(finalDataItem);
-                }
-            }
-            else if (typeof finalData !== 'undefined') {
-                await to(finalData);
-            }
-        }
-    }
-}
-staticPages.with = ({ from, to, controller }) => {
-    const withFunction = (newValue) => staticPages.with({
-        from: determineFrom(from, newValue.from),
-        to: determineTo(to, newValue.to),
-        controller: typeof newValue.controller !== 'undefined' ? newValue.controller : controller,
-    });
-    function modifiedStaticPages(...routes) {
-        return staticPages(...routes.map(route => {
-            var _a;
-            return ({
-                from: determineFrom(from, route.from),
-                to: determineTo(to, route.to),
-                controller: (_a = (typeof route.controller !== 'undefined' ? route.controller : controller)) !== null && _a !== void 0 ? _a : undefined,
-            });
-        }));
-    }
-    modifiedStaticPages.with = withFunction;
-    return modifiedStaticPages;
-};
-function determineFrom(oldValue, newValue) {
-    if (newValue && typeof newValue === 'object' && !isIterable(newValue) && !isAsyncIterable(newValue) &&
-        oldValue && typeof oldValue === 'object' && !isIterable(oldValue) && !isAsyncIterable(oldValue))
-        return { ...oldValue, ...newValue };
-    return typeof newValue !== 'undefined' ? newValue : oldValue;
-}
-function determineTo(oldValue, newValue) {
-    if (newValue && typeof newValue === 'object' &&
-        oldValue && typeof oldValue === 'object')
-        return { ...oldValue, ...newValue };
-    return typeof newValue !== 'undefined' ? newValue : oldValue;
-}