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

package/cjs/static-pages.d.ts

@@ -0,0 +1,54 @@
+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: AsyncIterable<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

@@ -0,0 +1,67 @@
+"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.`);
+        await to(asyncGenerator(from, controller));
+    }
+}
+exports.staticPages = staticPages;
+async function* asyncGenerator(items, controller) {
+    for await (const item of items) {
+        const data = controller ? await controller(item) : item;
+        if ((0, helpers_js_1.isIterable)(data) || (0, helpers_js_1.isAsyncIterable)(data)) {
+            yield* data;
+        }
+        else if (typeof data !== 'undefined') {
+            yield data;
+        }
+    }
+}
+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

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

package/esm/autoparse.js

@@ -0,0 +1,17 @@
+import { parse as parseYAML } from 'yaml';
+import parseMarkdown from 'gray-matter';
+export function autoparse(content, filename) {
+    const extension = filename.split('.').pop().toLowerCase();
+    switch (extension) {
+        case 'json':
+            return JSON.parse(content.toString());
+        case 'yaml':
+        case 'yml':
+            return parseYAML(content.toString());
+        case 'md':
+        case 'markdown':
+            const { data, content: markdownContent } = parseMarkdown(content.toString());
+            return { ...data, content: markdownContent };
+    }
+    throw new Error(`Could not parse document with '${extension}' extension.`);
+}

package/esm/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/esm/create-reader.js

@@ -0,0 +1,60 @@
+import picomatch from 'picomatch';
+import { autoparse } from './autoparse.js';
+import { getType, isIterable, isAsyncIterable, isFilesystem } from './helpers.js';
+import { join, relative } from 'node:path';
+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, { encoding: 'utf8', recursive: true, withFileTypes: true }, (err, files) => {
+            if (err)
+                reject(err);
+            else
+                resolve(files
+                    .filter(x => x.isFile())
+                    .map(x => join(relative(cwd, x.path), x.name)));
+        });
+    });
+    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(join(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

@@ -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/esm/create-writer.js

@@ -0,0 +1,71 @@
+import { getType, isIterable, isAsyncIterable, isFilesystem } from './helpers.js';
+import { dirname } from 'node:path';
+import * as nodeFs from '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.`);
+};
+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 (iterable) {
+        if (!isIterable(iterable) && !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 = 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

@@ -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/esm/helpers.js

@@ -0,0 +1,4 @@
+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/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/esm/index.js

@@ -1,32 +1,3 @@
-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';
-export 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 });
-    }
-}
-export default staticPages;
+export { staticPages, staticPages as default } from './static-pages.js';
+export { createReader } from './create-reader.js';
+export { createWriter } from './create-writer.js';

package/esm/static-pages.d.ts

@@ -0,0 +1,54 @@
+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: AsyncIterable<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

@@ -0,0 +1,63 @@
+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.`);
+        await to(asyncGenerator(from, controller));
+    }
+}
+async function* asyncGenerator(items, controller) {
+    for await (const item of items) {
+        const data = controller ? await controller(item) : item;
+        if (isIterable(data) || isAsyncIterable(data)) {
+            yield* data;
+        }
+        else if (typeof data !== 'undefined') {
+            yield data;
+        }
+    }
+}
+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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@static-pages/core",
-  "version": "6.0.0",
+  "version": "7.0.0-alpha.1",
   "description": "General purpose static pages renderer.",
   "type": "module",
   "main": "cjs/index.js",
@@ -12,20 +12,50 @@
       "default": "./esm/index.js"
     }
   },
+  "engines": {
+    "node": ">=16.0.0",
+    "deno": ">=1.0.0"
+  },
   "scripts": {
-    "prepack": "npm run test",
-    "clean": "rimraf esm cjs .nyc_output",
+    "prepack": "npm run build && npm run test",
+    "postversion": "git push && git push --tags",
+    "clean": "rimraf esm cjs coverage",
     "build": "npm run build:esm && npm run build:cjs",
     "build:esm": "tsc",
     "watch:esm": "tsc --watch",
-    "watch:cjs": "npm run build:cjs && tsc --project tsconfig.cjs.json --watch",
-    "build:cjs": "tsc --project tsconfig.cjs.json && echo { \"type\": \"commonjs\" }>cjs/package.json",
-    "test": "tap --nyc-arg=\"--exclude=cjs/index.js\" --node-arg=\"--no-warnings\" --node-arg=\"--experimental-loader\" --node-arg=\"@istanbuljs/esm-loader-hook\""
+    "build:cjs": "tsc --outDir cjs --module commonjs && echo { \"type\": \"commonjs\" }>cjs/package.json",
+    "watch:cjs": "npm run build:cjs && tsc --outDir cjs --module commonjs --watch",
+    "lint": "eslint",
+    "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"
   },
+  "author": "László BULIK",
+  "license": "MPL-2.0",
+  "homepage": "https://staticpagesjs.github.io/",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/staticpagesjs/core.git"
   },
+  "bugs": {
+    "url": "https://github.com/staticpagesjs/core/issues"
+  },
   "keywords": [
     "static",
     "pages",
@@ -36,22 +66,5 @@
     "view",
     "template",
     "controller"
-  ],
-  "author": "László BULIK",
-  "license": "MPL-2.0",
-  "bugs": {
-    "url": "https://github.com/staticpagesjs/core/issues"
-  },
-  "homepage": "https://staticpagesjs.github.io/",
-  "devDependencies": {
-    "@istanbuljs/esm-loader-hook": "^0.2.0",
-    "@types/node": "^14.18.9",
-    "@typescript-eslint/eslint-plugin": "^5.3.0",
-    "@typescript-eslint/parser": "^5.3.0",
-    "coveralls": "^3.1.1",
-    "eslint": "^8.1.0",
-    "rimraf": "^3.0.2",
-    "tap": "^16.3.4",
-    "typescript": "^4.4.4"
-  }
+  ]
 }