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

package/CHANGELOG.md

@@ -1,16 +1,16 @@
 # 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.
+## 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.
 - 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.
+- Use JS iterator protocol for the `route.to` callbacks.
+- Removed the `.teardown()` call on the `route.to` when iteration finished.
 
 
 ## 5.0.3
@@ -23,7 +23,7 @@
 - Updated maintenance badge in README.md.
 
 ## 5.0.0
-- Added a `.teardown()` call on the writer which is executed when iteration finished.
+- Added a `.teardown()` call on the `route.to` which is executed when iteration finished.
 - Provided better type definitions.
 
 

package/README.md

@@ -93,8 +93,8 @@ Each route consists of a `from`, `to` and a `controller` property matching the d
 
 ```ts
 interface Route<F, T> {
-    from?: Iterable<F> | AsyncIterable<F> | CreateReaderOptions<F>;
-    to?: { (data: AsyncIterable<T>): MaybePromise<void>; } | CreateWriterOptions<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>>;
 }
 
@@ -128,66 +128,35 @@ interface CreateWriterOptions<T> {
     onError?(error: unknown): MaybePromise<void>;
 }
 
-interface Stats {
-	isFile(): boolean;
-	isDirectory(): boolean;
-}
-
-interface Dirent {
-	name: string;
-	path: string;
-	isFile(): boolean;
-	isDirectory(): boolean;
-}
-
 interface Filesystem {
-	readdir(
+	stat(
 		path: string | URL,
-		options: {
-			encoding: 'utf8';
-			withFileTypes: false;
-			recursive: boolean;
-		},
-		callback: (err: Error | null, files: string[]) => void,
+		callback: (err: Error | null, stats: { isFile(): boolean; isDirectory(): boolean; }) => void
 	): void;
 
 	readdir(
 		path: string | URL,
 		options: {
 			encoding: 'utf8';
-			withFileTypes: true;
+			withFileTypes: false;
 			recursive: boolean;
 		},
-		callback: (err: Error | null, files: Dirent[]) => void,
+		callback: (err: Error | null, files: string[]) => void,
 	): void;
 
-	readFile(
+	mkdir(
 		path: string | URL,
 		options: {
-			encoding: 'utf8';
+			recursive: true;
 		},
-		callback: (err: Error | null, data: string) => void
+		callback: (err: Error | null, path?: 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,
@@ -203,7 +172,7 @@ When you use the `createReader` and `createWriter` interfaces to read and write
 ### `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.
+- `parse`: *see About the default `parse` function*
 - `onError`: `(err) => { throw err; }`
 
 ### `CreateWriterOptions` default parameters
@@ -213,6 +182,16 @@ When you use the `createReader` and `createWriter` interfaces to read and write
 - `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>; }`
 

package/cjs/create-writer.d.ts

@@ -8,7 +8,7 @@ export declare namespace createWriter {
         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 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

@@ -52,43 +52,39 @@ function createWriter({ fs = nodeFs, cwd = 'public', name = defaultNamer, render
         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);
-                        }
-                    });
+    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);
-                    });
+            });
+            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);
-            }
+            });
+        }
+        catch (error) {
+            await onError(error);
         }
     };
 }

package/cjs/static-pages.d.ts

@@ -5,7 +5,7 @@ export declare namespace staticPages {
     interface Route<F = unknown, T = unknown> {
         from?: Iterable<F> | AsyncIterable<F> | createReader.Options<F>;
         to?: {
-            (data: AsyncIterable<T>): MaybePromise<void>;
+            (data: T): MaybePromise<void>;
         } | createWriter.Options<T>;
         controller?(data: F): MaybePromise<undefined | T | Iterable<T> | AsyncIterable<T>>;
     }

package/cjs/static-pages.js

@@ -19,21 +19,20 @@ async function staticPages(...routes) {
             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;
+        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),

package/esm/create-writer.d.ts

@@ -8,7 +8,7 @@ export declare namespace createWriter {
         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 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

@@ -1,4 +1,4 @@
-import { getType, isIterable, isAsyncIterable, isFilesystem } from './helpers.js';
+import { getType, isFilesystem } from './helpers.js';
 import * as nodeFs from 'node:fs';
 import { dirname } from 'node:path';
 const defaultNamer = (data) => {
@@ -26,43 +26,39 @@ export function createWriter({ fs = nodeFs, cwd = 'public', name = defaultNamer,
         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);
-                        }
-                    });
+    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);
-                    });
+            });
+            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);
-            }
+            });
+        }
+        catch (error) {
+            await onError(error);
         }
     };
 }

package/esm/static-pages.d.ts

@@ -5,7 +5,7 @@ export declare namespace staticPages {
     interface Route<F = unknown, T = unknown> {
         from?: Iterable<F> | AsyncIterable<F> | createReader.Options<F>;
         to?: {
-            (data: AsyncIterable<T>): MaybePromise<void>;
+            (data: T): MaybePromise<void>;
         } | createWriter.Options<T>;
         controller?(data: F): MaybePromise<undefined | T | Iterable<T> | AsyncIterable<T>>;
     }

package/esm/static-pages.js

@@ -16,17 +16,16 @@ export async function staticPages(...routes) {
             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;
+        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);
+            }
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@static-pages/core",
-  "version": "7.0.0-alpha.3",
+  "version": "7.0.0-alpha.5",
   "description": "General purpose static pages renderer.",
   "type": "module",
   "main": "cjs/index.js",