nodoku-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 nodoku
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.MD

@@ -0,0 +1,46 @@
+nodoku-core is a foundation library for the nodoku static site generator, 
+a Node JS - React based framework for fast page prototyping using yaml files as content and page config
+The site in Nodoku is composed of two yaml files - visual and content.
+
+# getting started
+
+in order to use nodoku one needs to install the nodoku-core library (this one)
+and at least one component library for nodoku (for example, nodoku-flowbite)
+
+
+```shell
+npm install nodoku-core nodoku-flowbite
+```
+
+Then the rendering component would be as follows:
+
+```tsx
+<RenderingPage 
+    pageName={"main"}
+    lng={lng}
+    contentYamlProvider={contentYamlProvider}
+    visualYamlProvider={visualYamlProvider}
+    i18nextProvider={i18nextProvider}
+    componentProvider={defaultComponentProvider}
+    />
+```
+
+where:
+- **_pageName_**: the name of the page to be rendered. This name is given to the visualYamlProvider funtion to fetch the required page layout yaml file
+
+- **_lng_**: the page language for localization. This parameter is given further to the contentYamlProvider to fetch the content on the given language
+
+- **_contentYamlProvider_**: function providing the textual content for the page. This function is expected to fetch the content yaml file and return its content as text for the further processing. the function signature is the following: ```(lng: string, ns: string) => Promise<string>```
+
+- **_visualYamlProvider_**: function providing the content of a yaml file that is used to render the page - the page structure yaml file. This function is expected to fetch the content yaml file and return its content as text for the further processing. the function signature is the following: ```(pageName: string) => Promise<string>```
+
+- **_i18nextProvider_**: the page localization provider. The signature is the following: ```(lng: string) => Promise<{t: (key: string, ns: string) => string}>```. For a given language the localization provider is supposed to return a function, that would provide the value for a given key and namespace
+
+- **_componentProvider_**: the function returning an actual implementation of the component, given its name, as specified in the page structure - visual yaml file. The signature is as follows: ```(componentName: string) => Promise<AsyncFunctionComponent>```, where AsyncFunctionComponent is the following function: ```(props: LbComponentProps) => Promise<JSX.Element>```
+
+# generation scripts
+to simplify the development, the nodoku-core provides the following scripts, that are used to generate component resolver, content schema and visual schema, by scanning the **node_modules** folder of the project
+- **nodoku-gen-component-resolver**: generates the component resolver by scanning node_modules and searching for nodoku component libraries - the libraries providing the nodoku.manifest.json file
+- **nodoku-gen-content-schema**: generates the json schema file that can be used to validate the **content** yaml file
+- **nodoku-gen-visual-schema**: generates the json schema file thate can be used to validate the **visual** page yaml file 
+

package/dist/esm/bin/generate-component-resolver.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+import { register } from 'node:module';
+import { ComponentDef, Manifest } from "../content/manifest.js";
+import fs from "node:fs";
+import path from "path";
+import Mustache from "mustache";
+register('./import-load-hooks.js', import.meta.url);
+/*
+ * we need to use a dynamic import here since otherwise we have no guarantee that the template
+ * file won't start loading prior to hooks registration
+ * we register hooks, and only then use dynamic import to load custom template file
+ */
+// @ts-ignore
+const template = (await import("./mustache/default-component-resolver.ts.mtl")).default;
+function loadComponents(dir) {
+    const comps = new Map();
+    const files = fs.readdirSync(dir);
+    console.log("reading ...", dir);
+    for (const f of files) {
+        const stat = fs.statSync(`${dir}/${f}`);
+        if (stat.isDirectory()) {
+            const m = loadComponentsByManifest(`${dir}/${f}`, f);
+            if (m) {
+                comps.set(f, m);
+            }
+        }
+    }
+    return comps;
+}
+function loadComponentsByManifest(dir, moduleName) {
+    const files = fs.readdirSync(dir);
+    for (const f of files) {
+        const stat = fs.statSync(`${dir}/${f}`);
+        if (stat.isFile()) {
+            if (f == "nodoku.manifest.json") {
+                const manifest = new Manifest(moduleName);
+                console.log("found manifest ", `${dir}/${f}`, "reading...");
+                let json;
+                if (stat.isSymbolicLink()) {
+                    json = JSON.parse(fs.readlinkSync(`${dir}/nodoku.manifest.json`));
+                }
+                else {
+                    json = JSON.parse(fs.readFileSync(`${dir}/nodoku.manifest.json`).toString());
+                }
+                console.log("loaded manifest ", path.resolve(dir, f));
+                console.log("found manifest json ", json);
+                manifest.namespace = json.namespace;
+                Object.keys(json.components).forEach((k) => {
+                    const v = json.components[k];
+                    console.log("adding ", k, v);
+                    // comps.set(k, Manifest.from(k, moduleName, v));
+                    manifest.components.set(k, new ComponentDef(v.implementation, v.schema));
+                });
+                return manifest;
+            }
+        }
+    }
+    return undefined;
+}
+class TemplateView {
+    modules = new Map();
+    names = new Map();
+}
+function calculateTemplateView(dir = undefined) {
+    if (!dir) {
+        dir = path.resolve();
+    }
+    const components = loadComponents(`${dir}/node_modules`);
+    const tv = new TemplateView();
+    components.forEach((m, k) => {
+        if (!tv.modules.get(m.moduleName)) {
+            console.log("adding ", m.moduleName);
+            tv.modules.set(m.moduleName, []);
+        }
+        if (m.namespace) {
+            tv.modules.get(m.moduleName).push(m.namespace);
+            m.components.forEach((cd, cn) => {
+                tv.names.set(cn, `${m.namespace}.${cd.implementation}`);
+            });
+        }
+        else {
+            m.components.forEach((cd, cn) => {
+                tv.modules.get(m.moduleName).push(cd.implementation);
+                tv.names.set(cn, cd.implementation);
+            });
+        }
+    });
+    return tv;
+}
+export function generateComponentResolver() {
+    const args = process.argv.slice(2);
+    const dir = path.resolve();
+    const src = args[0] ? args[0] : "./src";
+    console.log("generating component resolver");
+    const tv = calculateTemplateView();
+    const view = {
+        modules: Array.from(tv.modules.entries()).map((e) => {
+            return { "module": e[0], "comps": e[1].join(", ") };
+        }),
+        names: Array.from(tv.names.entries()).map((n) => { return { n: n[0], c: n[1] }; })
+    };
+    console.log("view", JSON.stringify(view));
+    const output = Mustache.render(template, view);
+    const fileName = `${dir}/${src}/nodoku-component-resolver.ts`;
+    fs.writeFile(fileName, output, err => {
+        if (err) {
+            return console.error(err);
+        }
+        console.log(`${fileName}: File created!`);
+    });
+}
+generateComponentResolver();

package/dist/esm/bin/generate-content-schema.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { register } from 'node:module';
+import fs from "node:fs";
+import path from "path";
+import Mustache from "mustache";
+register('./import-load-hooks.js', import.meta.url);
+/*
+ * we need to use a dynamic import here since otherwise we have no guarantee that the template
+ * file won't start loading prior to hooks registration
+ * we register hooks, and only then use dynamic import to load custom template file
+ */
+// @ts-ignore
+const template = (await import("./mustache/content-schema.json.mtl")).default;
+const linkRegexPattern = "^((http|https)?:\\\\/\\\\/)?\\\\/?([-a-zA-Z0-9._\\\\+~#=]{1,256})([-a-zA-Z0-9@:%._\\\\+~#=]{1,256})([-a-zA-Z0-9()@:%_\\\\+.~#?&\\\\/\\\\/=]*)$";
+export function generateContentSchema() {
+    const args = process.argv.slice(2);
+    const dir = path.resolve();
+    const schemaSrc = args[0] ? args[0] : "./schemas";
+    console.log("generating content schema");
+    const view = { linkRegexPattern };
+    const output = Mustache.render(template, view);
+    const fileName = `${dir}/${schemaSrc}/content-schema.json`;
+    fs.writeFile(fileName, output, err => {
+        if (err) {
+            return console.error(err);
+        }
+        console.log(`${fileName}: File created!`);
+    });
+}
+generateContentSchema();

package/dist/esm/bin/generate-visual-schema.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+import { register } from 'node:module';
+import { ComponentDef, Manifest } from "../content/manifest.js";
+import fs from "node:fs";
+import path from "path";
+import Mustache from "mustache";
+register('./import-load-hooks.js', import.meta.url);
+/*
+ * we need to use a dynamic import here since otherwise we have no guarantee that the template
+ * file won't start loading prior to hooks registration
+ * we register hooks, and only then use dynamic import to load custom template file
+ */
+// @ts-ignore
+const template = (await import("./mustache/visual-schema.json.mtl")).default;
+function loadComponents(dir) {
+    const comps = new Map();
+    const files = fs.readdirSync(dir);
+    console.log("reading ...", dir);
+    for (const f of files) {
+        const stat = fs.statSync(`${dir}/${f}`);
+        if (stat.isDirectory()) {
+            const m = loadComponentsByManifest(`${dir}/${f}`, f);
+            if (m) {
+                comps.set(f, m);
+            }
+        }
+    }
+    return comps;
+}
+function loadComponentsByManifest(dir, moduleName) {
+    const files = fs.readdirSync(dir);
+    for (const f of files) {
+        const stat = fs.statSync(`${dir}/${f}`);
+        if (stat.isFile()) {
+            if (f == "nodoku.manifest.json") {
+                const manifest = new Manifest(moduleName);
+                console.log("found manifest ", `${dir}/${f}`, "reading...");
+                let json;
+                if (stat.isSymbolicLink()) {
+                    json = JSON.parse(fs.readlinkSync(`${dir}/nodoku.manifest.json`));
+                }
+                else {
+                    json = JSON.parse(fs.readFileSync(`${dir}/nodoku.manifest.json`).toString());
+                }
+                console.log("loaded manifest ", path.resolve(dir, f));
+                console.log("found manifest json ", json);
+                manifest.namespace = json.namespace;
+                Object.keys(json.components).forEach((k) => {
+                    const v = json.components[k];
+                    console.log("adding ", k, v);
+                    // comps.set(k, Manifest.from(k, moduleName, v));
+                    manifest.components.set(k, new ComponentDef(v.implementation, v.schemaFile));
+                });
+                return manifest;
+            }
+        }
+    }
+    return undefined;
+}
+class TemplateView {
+    components = new Map();
+}
+function calculateTemplateView(schemaDestinationDir, dirNodeModules = undefined) {
+    if (!dirNodeModules) {
+        dirNodeModules = `${path.resolve()}/node_modules`;
+    }
+    const components = loadComponents(dirNodeModules);
+    const tv = new TemplateView();
+    components.forEach((m) => {
+        m.components.forEach((cd, cn) => {
+            const moduleDir = `${dirNodeModules}/${m.moduleName}`;
+            const { content, dest } = readSchema(schemaDestinationDir, m.moduleName, moduleDir, cd.schemaFile);
+            const resolvedContent = resolveRefsInSchema(content, m.moduleName, dirNodeModules, schemaDestinationDir, cd.schemaFile);
+            const schemaFile = writeSchema(dest, resolvedContent);
+            const res = schemaFile.startsWith(schemaDestinationDir) ? schemaFile.replace(stripTrailingSlash(schemaDestinationDir), ".") : schemaFile;
+            tv.components.set(cn, res);
+        });
+    });
+    const compSchemas = [];
+    let i = 0;
+    tv.components.forEach((v, k) => {
+        compSchemas.push({ name: k, schema: v, isLast: i == tv.components.size - 1 });
+        i++;
+    });
+    return { components: compSchemas };
+}
+function resolveRefsInSchema(schemaFileContent, moduleName, dirNodeModules, schemaDestinationDir, schemaFileRelativeToModuleDir) {
+    const regex = /\s*"\$ref": "(.*)"/;
+    const refs = [];
+    for (const line of schemaFileContent.split("\n")) {
+        const matched = regex.exec(line);
+        if (matched) {
+            let ref = matched[1];
+            if (ref.indexOf("#") >= 0) {
+                ref = ref.substring(0, ref.indexOf("#"));
+            }
+            if (ref.length > 0) {
+                refs.push(ref);
+            }
+        }
+    }
+    const correctedRefs = new Map();
+    refs.forEach(r => {
+        correctedRefs.set(r, resolveRef(r, moduleName, dirNodeModules, schemaDestinationDir, schemaFileRelativeToModuleDir));
+    });
+    let res = schemaFileContent;
+    correctedRefs.forEach((v, k) => {
+        console.log("replacing ref", k, "by", v);
+        res = res.replaceAll(k, v);
+    });
+    return res;
+}
+function resolveRef(ref, moduleName, dirNodeModules, schemaDestinationDir, schemaFileRelativeToModuleDir) {
+    const isAbsolute = path.isAbsolute(ref);
+    if (isAbsolute) {
+        return ref;
+    }
+    let relativeSchemaFileLocation = schemaFileRelativeToModuleDir;
+    if (schemaFileRelativeToModuleDir.endsWith(".json")) {
+        relativeSchemaFileLocation = schemaFileRelativeToModuleDir.substring(0, schemaFileRelativeToModuleDir.lastIndexOf("/"));
+    }
+    const fileName = `${schemaDestinationDir}/${relativeSchemaFileLocation}/${ref}`;
+    let stat = undefined;
+    try {
+        console.log("searching for ref file: ", path.resolve(fileName));
+        stat = fs.statSync(path.resolve(fileName));
+    }
+    catch (e) {
+        // file doesn't exist
+    }
+    if (stat && stat.isFile()) {
+        console.log("file is found");
+        return ref;
+    }
+    const k = ref.indexOf("node_modules");
+    if (k >= 0) {
+        const schemaFileDir = path.resolve(`${schemaDestinationDir}/${moduleName}/${relativeSchemaFileLocation}`);
+        const relativePathToNodeModules = path.relative(schemaFileDir, dirNodeModules);
+        console.log("resolving diff: schemaFileDir", schemaFileDir, "dirNodeModules", dirNodeModules, "relative path", relativePathToNodeModules);
+        ref = `${relativePathToNodeModules}/${stripLeadingSlash(ref.substring(k + "node_modules".length))}`;
+    }
+    ref = ref.replaceAll("\\", "/");
+    console.log("returning ref", ref);
+    return ref;
+}
+function readSchema(schemaDestinationDir, moduleName, moduleDir, compSchema) {
+    const moduleSchemaFile = `${stripTrailingSlash(moduleDir)}/${stripLeadingSlash(compSchema)}`;
+    console.log("module dir", moduleDir);
+    let destSchemaFile = `${moduleName}/${stripLeadingSlash(compSchema)}`;
+    const dest = `${schemaDestinationDir}/${destSchemaFile}`;
+    const moduleSchemaFilePath = moduleSchemaFile.replaceAll("/", "\\");
+    const stat = fs.statSync(moduleSchemaFilePath);
+    let content;
+    if (stat.isSymbolicLink()) {
+        content = fs.readlinkSync(moduleSchemaFile);
+    }
+    else {
+        content = fs.readFileSync(moduleSchemaFile).toString();
+    }
+    console.log("read content of file:", moduleSchemaFilePath, ", to be copied to", dest);
+    return { content, dest };
+}
+function writeSchema(dest, content) {
+    console.log("dest", dest);
+    const destSchemaDir = dest.substring(0, dest.lastIndexOf("/"));
+    fs.mkdirSync(destSchemaDir, { recursive: true });
+    fs.writeFileSync(path.resolve(dest), content);
+    return dest;
+}
+function stripTrailingSlash(path) {
+    if (path.endsWith("/")) {
+        return path.substring(0, path.length - 1);
+    }
+    return path;
+}
+function stripLeadingSlash(path) {
+    if (path.startsWith("/")) {
+        return path.substring(1);
+    }
+    else if (path.startsWith("./")) {
+        return path.substring(2);
+    }
+    return path;
+}
+export function generateVisualSchema() {
+    const args = process.argv.slice(2);
+    const dir = path.resolve();
+    const schemaSrc = args[0] ? args[0] : "./schemas";
+    console.log("generating visual schema");
+    const view = calculateTemplateView(schemaSrc);
+    const output = Mustache.render(template, view);
+    const fileName = `${dir}/${schemaSrc}/visual-schema.json`;
+    fs.writeFile(fileName, output, err => {
+        if (err) {
+            return console.error(err);
+        }
+        console.log(`${fileName}: File created!`);
+    });
+}
+generateVisualSchema();

package/dist/esm/bin/import-load-hooks.js

@@ -0,0 +1,30 @@
+import path from "path";
+import * as nodeUrl from "node:url";
+import { open } from 'node:fs/promises';
+export async function initialize(props) {
+    console.log("Receives data from `register`", props);
+}
+export async function resolve(specifier, context, nextResolve) {
+    console.log("Take an `import` or `require` specifier and resolve it to a URL.", specifier, context, nextResolve);
+    return nextResolve(specifier, context, nextResolve);
+}
+export async function load(url, context, nextLoad) {
+    console.log("Take a resolved URL and return the source code to be evaluated.", url, context, nextLoad);
+    if (url.endsWith(".mtl")) {
+        const prefix = path.resolve("./");
+        const filePath = nodeUrl.fileURLToPath(url);
+        const file = await open(filePath);
+        var templateContent = [];
+        for await (const line of file.readLines()) {
+            templateContent.push(`"${line.replaceAll("\"", "\\\"")}"`);
+        }
+        const src = `const l = ${templateContent.join(" + \"\\n\" + ")}; export default l;`;
+        const res = {
+            format: "module",
+            shortCircuit: true,
+            source: src
+        };
+        return res;
+    }
+    return nextLoad(url, context, nextLoad);
+}

package/dist/esm/bin/mustache/content-schema.json.mtl

@@ -0,0 +1,92 @@
+{
+  "description": "Landing buddy content page schema",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "Link": {
+      "type": "string",
+      "pattern": "{{{linkRegexPattern}}}"
+    },
+    "Image": {
+      "type": "object",
+      "properties": {
+        "title": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string"
+        },
+        "alt": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "url"
+      ]
+    },
+    "ContentBlock": {
+      "type": "object",
+      "properties": {
+        "title": {
+          "type": "string"
+        },
+        "subTitle": {
+          "type": "string"
+        },
+        "footer": {
+          "type": "string"
+        },
+        "images": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Image"
+          }
+        },
+        "paragraphs": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "bgImage": {
+          "$ref": "#/definitions/Image"
+        },
+        "links": {
+          "properties": {
+            "titleLink": {
+              "$ref": "#/definitions/Link"
+            },
+            "subTitleLink": {
+              "$ref": "#/definitions/Link"
+            },
+            "footerLink": {
+              "$ref": "#/definitions/Link"
+            },
+            "imageLinks": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/Link"
+              }
+            },
+            "paragraphLinks": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/Link"
+              }
+            },
+            "blockLink": {
+              "$ref": "#/definitions/Link"
+            }
+          },
+          "additionalItems": false,
+          "additionalProperties": false
+        }
+      },
+      "additionalItems": false,
+      "additionalProperties": false
+    }
+  },
+  "type": "object",
+  "additionalProperties": {
+    "$ref": "#/definitions/ContentBlock"
+  }
+}

package/dist/esm/bin/mustache/default-component-resolver.ts.mtl

@@ -0,0 +1,16 @@
+import {AsyncFunctionComponent, DummyComp} from "nodoku-core";
+
+{{#modules}}
+import { {{comps}} } from "{{module}}";
+{{/modules}}
+
+const components: Map<string, AsyncFunctionComponent> = new Map<string, AsyncFunctionComponent>();
+
+{{#names}}
+components.set("{{{n}}}", {{c}})
+{{/names}}
+
+export function defaultComponentProvider(componentName: string): Promise<AsyncFunctionComponent> {
+    const f: AsyncFunctionComponent | undefined = components.get(componentName);
+    return Promise.resolve(f ? f : DummyComp);
+}

package/dist/esm/bin/mustache/visual-schema.json.mtl

@@ -0,0 +1,40 @@
+{
+  "description": "Nodoku visual page schema",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "VisualRow": {
+      "type": "object",
+      "properties": {
+        "row": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/VisualRowBlock"
+          }
+        }
+      },
+      "additionalProperties": false
+    },
+    "VisualRowBlock": {
+      "type": "object",
+      "properties": {
+      {{#components}}
+        "{{{name}}}": {
+          "$ref": "{{{schema}}}"
+        }{{^isLast}},{{/isLast}}
+      {{/components}}
+      },
+      "additionalProperties": false
+    },
+    "additionalProperties": false
+  },
+  "type": "object",
+  "properties": {
+    "rows": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/VisualRow"
+      }
+    },
+    "additionalProperties": false
+  }
+}

package/dist/esm/content/lb-content-block.js

@@ -0,0 +1,81 @@
+export class LbContentImage {
+    url;
+    title;
+    alt;
+}
+export class LbTranslatedText {
+    key = "";
+    ns = "";
+    text = "";
+    constructor(ns, key = "", text = "") {
+        this.ns = ns;
+        this.key = key;
+        this.text = text;
+    }
+}
+export class LbContentBlock {
+    key;
+    title;
+    subTitle;
+    footer;
+    paragraphs = [];
+    bgImage;
+    images = [];
+    constructor(key) {
+        this.key = key;
+    }
+}
+export class LbNsContent {
+    blocks = [];
+}
+export class LbContentKey {
+    key;
+    ns;
+    constructor(key, ns) {
+        this.key = key;
+        this.ns = ns;
+    }
+}
+export class LbVisualComponent {
+    rowIndex;
+    componentIndex;
+    visualComponent = "";
+    ns = "";
+    contentKeys = [];
+    theme;
+    options;
+    implementationModule = "";
+    implementationComponent = "";
+    constructor(rowIndex, componentIndex) {
+        this.rowIndex = rowIndex;
+        this.componentIndex = componentIndex;
+    }
+}
+export class LbRow {
+    rowIndex;
+    row = [];
+    constructor(rowIndex) {
+        this.rowIndex = rowIndex;
+    }
+}
+export class LbPageVisual {
+    rows = [];
+}
+export class LbComponentProps {
+    rowIndex;
+    componentIndex;
+    content;
+    visual;
+    options;
+    lng;
+    i18nextProvider;
+    constructor(rowIndex, componentIndex, content, visual, options, lng, i18nextProvider) {
+        this.rowIndex = rowIndex;
+        this.componentIndex = componentIndex;
+        this.content = content;
+        this.visual = visual;
+        this.options = options;
+        this.lng = lng;
+        this.i18nextProvider = i18nextProvider;
+    }
+}

package/dist/esm/content/manifest.js

@@ -0,0 +1,16 @@
+export class ComponentDef {
+    implementation;
+    schemaFile;
+    constructor(componentImplementation, componentSchema) {
+        this.implementation = componentImplementation;
+        this.schemaFile = componentSchema;
+    }
+}
+export class Manifest {
+    moduleName;
+    namespace = undefined;
+    components = new Map();
+    constructor(moduleName) {
+        this.moduleName = moduleName;
+    }
+}

package/dist/esm/content/providers.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/dummy-comp.jsx

@@ -0,0 +1,69 @@
+export async function DummyComp(props) {
+    console.log("content dummy comp", props.content);
+    const { content, i18nextProvider, lng } = props;
+    const { t } = await i18nextProvider(lng);
+    const blocks = content.map((block) => {
+        var style = {};
+        if (block.bgImage && block.bgImage.url) {
+            style = { backgroundImage: `url(${t(block.bgImage.url.key, block.bgImage.url.ns)})` };
+        }
+        return (<div className={"w-full w-full flex flex-col items-left justify-left  border border-4 border-red-200 relative pb-10"}>
+                <div className={"top-0 bottom-0 left-0 right-0 absolute bg-cover bg-no-repeat"} style={{ ...style, zIndex: -11 }}>
+                </div>
+                <div className={"top-0 bottom-0 left-0 right-0 absolute bg-white "} style={{ zIndex: -5, opacity: 0.7 }}>
+                </div>
+                <div className={"p-5 w-full bg-red-400 text-center"}>dummy component<h3><b>{block.key}</b></h3></div>
+
+
+                <div className="p-5">
+                    {block.title && <a href="#">
+                        {block.title && block.title.key}
+                        <h5 className={"mb-2 text-2xl font-bold tracking-tight text-gray-900 dark:text-white"}>
+                            {block.title && t(block.title.key, block.title.ns)}
+                        </h5>
+                    </a>}
+                    {block.subTitle && block.subTitle.key}
+                    {block.subTitle && <h6 className={"mb-2 text-xl tracking-tight text-gray-900 dark:text-white"}>
+                        {block.subTitle && t(block.subTitle.key, block.subTitle.ns)}
+                    </h6>}
+
+                    paragraphs:
+                    {block.paragraphs.map((p, ip) => {
+                return (<div>
+                                {p && p.key}
+                                <p key={ip} className={"mb-3 font-normal text-gray-700 dark:text-gray-400"}>
+                                    {p && t(p.key, p.ns)}
+                                </p>
+                            </div>);
+            })}
+                    images:
+                    {block.images.map((i, ii) => {
+                return (<div>
+                                <p key={"url" + ii} className={"mb-3 font-normal text-gray-700 dark:text-gray-400"}>
+                                    url: {i && i.url && t(i.url.key, i.url.ns)}
+                                    {i.url && <span className={"bg-cover bg-no-repeat"} style={{
+                            display: "block",
+                            width: "200px",
+                            height: "200px",
+                            backgroundImage: `url(${t(i.url.key, i.url.ns)})`
+                        }}></span>}
+                                </p>
+                                <p key={"alt" + ii} className={"mb-3 font-normal text-gray-700 dark:text-gray-400"}>
+                                    alt: {i && i.alt && t(i.alt.key, i.alt.ns)}
+                                </p>
+                                <p key={"title" + ii} className={"mb-3 font-normal text-gray-700 dark:text-gray-400"}>
+                                    title: {i && i.title && t(i.title.key, i.title.ns)}
+                                </p>
+                            </div>);
+            })}
+                </div>
+
+                <div className={"absolute bottom-0 p-5"}>
+                    {block.footer?.key}
+                    <p>{block.footer && t(block.footer.key, block.footer.ns)}</p>
+                </div>
+
+            </div>);
+    });
+    return <div>{blocks}</div>;
+}

package/dist/esm/core/rendering-page-props.js

@@ -0,0 +1,16 @@
+export class RenderingPageProps {
+    pageName;
+    lng;
+    i18nextProvider;
+    contentYamlProvider;
+    visualYamlProvider;
+    componentProvider;
+    constructor(pageName, lng, i18nextProvider, contentYamlProvider, visualYamlProvider, componentProvider) {
+        this.pageName = pageName;
+        this.lng = lng;
+        this.i18nextProvider = i18nextProvider;
+        this.contentYamlProvider = contentYamlProvider;
+        this.visualYamlProvider = visualYamlProvider;
+        this.componentProvider = componentProvider;
+    }
+}

package/dist/esm/core/rendering-page.jsx

@@ -0,0 +1,166 @@
+import * as yaml from "js-yaml";
+import React from "react";
+import { LbContentBlock, LbContentImage, LbContentKey, LbNsContent, LbRow, LbTranslatedText, LbVisualComponent } from "../content/lb-content-block";
+import { DummyComp } from "./dummy-comp";
+async function defaultComponentProvider(componentName) {
+    return DummyComp;
+}
+async function fetchPageContent(lng, namespaces, provider) {
+    const pageContent = new Map();
+    await Promise.all(namespaces.map(ns => readFileContent(lng, ns, pageContent, provider)));
+    // console.log("content", res)
+    return pageContent;
+}
+async function readFileContent(lng, ns, pageContent, provider) {
+    console.log("fetching file content", lng, ns);
+    await provider(lng, ns)
+        .then((fileContent) => pageContent.set(ns, fetchSuccessContent(fileContent, ns)));
+}
+async function fetchPageVisual(pageName, provider) {
+    const res = await provider(pageName)
+        .then(fetchSuccessVisual);
+    console.log("all visual", JSON.stringify(res));
+    return res;
+}
+function fetchSuccessContent(fileContents, ns) {
+    const data = yaml.load(fileContents);
+    console.log("LbPageContent", Object.keys(data));
+    const res = new LbNsContent();
+    res.blocks = Object.keys(data).map(((key, bi) => {
+        const b = data[key];
+        const blockPrefix = key;
+        const bRes = new LbContentBlock(key);
+        bRes.title = new LbTranslatedText(ns);
+        bRes.title.key = `${blockPrefix}.title`;
+        bRes.title.text = b.header;
+        bRes.subTitle = new LbTranslatedText(ns);
+        bRes.subTitle.key = `${blockPrefix}.subTitle`;
+        bRes.subTitle.text = b.subHeader;
+        bRes.footer = new LbTranslatedText(ns);
+        bRes.footer.key = `${blockPrefix}.footer`;
+        bRes.footer.text = b.footer;
+        bRes.paragraphs = b.paragraphs ? b.paragraphs.map(((p, pi) => new LbTranslatedText(ns, `${key}.paragraphs.${pi}`, p))) : [];
+        bRes.images = b.images ? b.images.map(((im, imi) => {
+            const pRes = new LbContentImage();
+            pRes.url = new LbTranslatedText(ns, `${key}.images.${imi}.url`, im.url);
+            pRes.alt = new LbTranslatedText(ns, `${key}.images.${imi}.alt`, im.alt);
+            pRes.title = new LbTranslatedText(ns, `${key}.images.${imi}.title`, im.title);
+            return pRes;
+        })) : [];
+        if (b.bgImage) {
+            bRes.bgImage = new LbContentImage();
+            bRes.bgImage.url = new LbTranslatedText(ns, `${key}.bgImage.url`, b.bgImage.url);
+            bRes.bgImage.alt = new LbTranslatedText(ns, `${key}.bgImage.alt`, b.bgImage.alt);
+            bRes.bgImage.alt = new LbTranslatedText(ns, `${key}.bgImage.title`, b.bgImage.title);
+        }
+        return bRes;
+    }));
+    return res;
+}
+function fetchSuccessVisual(fileContents) {
+    const data = yaml.load(fileContents);
+    return {
+        rows: data.rows.map(((r, iRow) => {
+            const row = new LbRow(iRow);
+            row.row = r.row.map((vc, iVc) => {
+                console.log("Object.keys(vc)", Object.keys(vc));
+                const vcName = Object.keys(vc)[0];
+                const lbVisualComponent = new LbVisualComponent(iRow, iVc);
+                lbVisualComponent.visualComponent = vcName;
+                const vb = vc[lbVisualComponent.visualComponent];
+                lbVisualComponent.ns = vb.ns;
+                lbVisualComponent.contentKeys = convertContentKeys(vb, lbVisualComponent.ns);
+                lbVisualComponent.theme = vb.theme;
+                lbVisualComponent.options = vb.options;
+                lbVisualComponent.implementationModule = "nodoku-flowbite";
+                lbVisualComponent.implementationComponent = lbVisualComponent.visualComponent;
+                return lbVisualComponent;
+            });
+            return row;
+        }))
+    };
+}
+function convertContentKeys(vb, defaultNs) {
+    var contentKeys = vb.contentKeys;
+    if (!contentKeys && vb.contentKey) {
+        contentKeys = [vb.contentKey];
+    }
+    if (!contentKeys || !contentKeys.length) {
+        return [];
+    }
+    return contentKeys.map((ck) => {
+        if (typeof ck == "string") {
+            return new LbContentKey(ck, defaultNs);
+        }
+        else {
+            return new LbContentKey(ck.key, ck.ns ? ck.ns : defaultNs);
+        }
+    });
+}
+async function RenderingPage(props) {
+    const { pageName, lng, i18nextProvider, contentYamlProvider, visualYamlProvider } = props;
+    var { componentProvider } = props;
+    if (!componentProvider) {
+        componentProvider = defaultComponentProvider;
+    }
+    const pageVisual = await fetchPageVisual(pageName, visualYamlProvider);
+    const namespaces = new Set();
+    pageVisual.rows.forEach((r) => {
+        r.row.forEach((vc) => {
+            vc.contentKeys.forEach((ck) => {
+                console.log(ck.ns);
+                namespaces.add(ck.ns);
+            });
+        });
+    });
+    const pageContent = await fetchPageContent(lng, Array.from(namespaces.keys()), contentYamlProvider);
+    const l = await Promise.all(pageVisual.rows.map(async (row, iRow) => {
+        return await createSubRows(row, iRow, pageContent, lng, i18nextProvider, componentProvider);
+    }));
+    const rows = l.flatMap((a) => a);
+    return <>{rows}</>;
+}
+async function createSubRows(row, iRow, pageContent, lng, i18nProvider, componentProvider) {
+    const rowComponents = await Promise.all(row.row.map(async (visualSection, iComp) => {
+        return await createRowBlock(iRow, iComp, visualSection, pageContent, lng, i18nProvider, componentProvider);
+    }));
+    const numComponents = rowComponents.length;
+    if (numComponents == 1) {
+        return [rowComponents[0]];
+    }
+    else {
+        const maxCols = 3;
+        const numCols = numComponents <= maxCols ? numComponents : maxCols;
+        const subRows = [];
+        for (var i = 0; i < numComponents / numCols; i++) {
+            subRows.push(<div key={`row-${iRow}`} className={`grid grid-cols-${numCols} gap-4 ${iRow == 0 ? "" : "mt-10"}`}>
+                    {rowComponents.slice(numCols * i, Math.min((i + 1) * numCols, numComponents))}
+                </div>);
+        }
+        return subRows;
+    }
+}
+async function createRowBlock(rowIndex, componentIndex, visualSection, pageContent, lng, i18nProvider, componentProvider) {
+    const blocks = visualSection.contentKeys
+        .map((k) => pageContent.get(k.ns)?.blocks.find((b) => b.key == k.key))
+        .filter((b) => b != undefined)
+        .map((b) => b);
+    console.log("retrieving comp", rowIndex, componentIndex);
+    const component = await componentProvider(visualSection.implementationComponent);
+    console.log("after component");
+    return renderWithVisual(rowIndex, componentIndex, component, blocks, visualSection, lng, i18nProvider);
+}
+async function renderWithVisual(rowIndex, componentIndex, component, section, visualSection, lng, i18nextProvider) {
+    console.log("start rendering page");
+    const props = {
+        rowIndex: rowIndex,
+        componentIndex: componentIndex,
+        content: section,
+        visual: visualSection.theme,
+        options: visualSection.options,
+        lng: lng,
+        i18nextProvider: i18nextProvider
+    };
+    return await component(props);
+}
+export { RenderingPage };

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+import { LbContentImage, LbTranslatedText, LbContentBlock, LbNsContent, LbContentKey, LbVisualComponent, LbRow, LbPageVisual, LbComponentProps } from "./content/lb-content-block";
+import { RenderingPageProps } from "./core/rendering-page-props";
+import { RenderingPage } from "./core/rendering-page";
+export { LbContentImage, LbTranslatedText, LbContentBlock, LbNsContent, LbContentKey, LbVisualComponent, LbRow, LbPageVisual, LbComponentProps };
+export { RenderingPageProps, RenderingPage };
+export { DummyComp } from "./core/dummy-comp";

package/dist/schemas/content-common-schema.json

@@ -0,0 +1,90 @@
+{
+  "description": "Nodoku content page schema",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "Link": {
+      "type": "string",
+      "pattern": "^((http|https)?:\\/\\/)?\\/?([-a-zA-Z0-9._\\+~#=]{1,256})([-a-zA-Z0-9@:%._\\+~#=]{1,256})([-a-zA-Z0-9()@:%_\\+.~#?&\\/\\/=]*)$"
+    },
+    "Image": {
+      "type": "object",
+      "properties": {
+        "title": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string"
+        },
+        "alt": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "url"
+      ]
+    },
+    "ContentBlock": {
+      "type": "object",
+      "properties": {
+        "title": {
+          "type": "string"
+        },
+        "subTitle": {
+          "type": "string"
+        },
+        "footer": {
+          "type": "string"
+        },
+        "images": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Image"
+          }
+        },
+        "paragraphs": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "bgImage": {
+          "$ref": "#/definitions/Image"
+        },
+        "links": {
+          "properties": {
+            "titleLink": {
+              "$ref": "#/definitions/Link"
+            },
+            "subTitleLink": {
+              "$ref": "#/definitions/Link"
+            },
+            "footerLink": {
+              "$ref": "#/definitions/Link"
+            },
+            "imageLinks": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/Link"
+              }
+            },
+            "paragraphLinks": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/Link"
+              }
+            },
+            "blockLink": {
+              "$ref": "#/definitions/Link"
+            }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "type": "object",
+  "additionalProperties": {
+    "$ref": "#/definitions/ContentBlock"
+  }
+}

package/dist/schemas/manifest-schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "namespace": {
+      "type": "string"
+    },
+    "components": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "schemaFile": {
+            "type": "string"
+          },
+          "implementation": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "schemaFile",
+          "implementation"
+        ],
+        "additionalProperties": false
+      }
+    }
+  },
+  "required": [
+    "components"
+  ],
+  "additionalProperties": false
+}

package/dist/schemas/visual-common-schema.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "ContentKey": {
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "ns": {
+              "type": "string",
+              "pattern": "[\\w-]+"
+            },
+            "key": {
+              "type": "string",
+              "pattern": "[\\w-]+"
+            }
+          },
+          "required": [
+            "key"
+          ],
+          "additionalProperties": false
+        },
+        {
+          "type": "string"
+        }
+      ]
+    }
+  }
+}

package/dist/types/bin/generate-component-resolver.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function generateComponentResolver(): void;

package/dist/types/bin/generate-content-schema.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function generateContentSchema(): void;

package/dist/types/bin/generate-visual-schema.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function generateVisualSchema(): void;

package/dist/types/bin/import-load-hooks.d.ts

@@ -0,0 +1,3 @@
+export declare function initialize(props: any): Promise<void>;
+export declare function resolve(specifier: any, context: any, nextResolve: any): Promise<any>;
+export declare function load(url: any, context: any, nextLoad: any): Promise<any>;

package/dist/types/content/lb-content-block.d.ts

@@ -0,0 +1,60 @@
+import { i18nextProvider } from "./providers";
+export declare class LbContentImage {
+    url?: LbTranslatedText;
+    title?: LbTranslatedText;
+    alt?: LbTranslatedText;
+}
+export declare class LbTranslatedText {
+    key: string;
+    ns: string;
+    text: string;
+    constructor(ns: string, key?: string, text?: string);
+}
+export declare class LbContentBlock {
+    key: string;
+    title?: LbTranslatedText;
+    subTitle?: LbTranslatedText;
+    footer?: LbTranslatedText;
+    paragraphs: LbTranslatedText[];
+    bgImage?: LbContentImage;
+    images: LbContentImage[];
+    constructor(key: string);
+}
+export declare class LbNsContent {
+    blocks: LbContentBlock[];
+}
+export declare class LbContentKey {
+    key: string;
+    ns: string;
+    constructor(key: string, ns: string);
+}
+export declare class LbVisualComponent {
+    rowIndex: number;
+    componentIndex: number;
+    visualComponent: string;
+    ns: string;
+    contentKeys: LbContentKey[];
+    theme: any;
+    options: any;
+    implementationModule: string;
+    implementationComponent: string;
+    constructor(rowIndex: number, componentIndex: number);
+}
+export declare class LbRow {
+    rowIndex: number;
+    row: LbVisualComponent[];
+    constructor(rowIndex: number);
+}
+export declare class LbPageVisual {
+    rows: LbRow[];
+}
+export declare class LbComponentProps<TComponentTheme = any, TComponentOptions = any> {
+    rowIndex: number;
+    componentIndex: number;
+    content: LbContentBlock[];
+    visual: TComponentTheme;
+    options: TComponentOptions;
+    lng: string;
+    i18nextProvider: i18nextProvider;
+    constructor(rowIndex: number, componentIndex: number, content: LbContentBlock[], visual: TComponentTheme, options: TComponentOptions, lng: string, i18nextProvider: i18nextProvider);
+}

package/dist/types/content/manifest.d.ts

@@ -0,0 +1,11 @@
+export declare class ComponentDef {
+    implementation: string;
+    schemaFile: string;
+    constructor(componentImplementation: string, componentSchema: string);
+}
+export declare class Manifest {
+    moduleName: string;
+    namespace: string | undefined;
+    components: Map<string, ComponentDef>;
+    constructor(moduleName: string);
+}

package/dist/types/content/providers.d.ts

@@ -0,0 +1,9 @@
+import { LbComponentProps } from "./lb-content-block";
+import { JSX } from "react";
+export type AsyncFunctionComponent = (props: LbComponentProps) => Promise<JSX.Element>;
+export type ContentYamlProvider = (lng: string, ns: string) => Promise<string>;
+export type VisualYamlProvider = (pageName: string) => Promise<string>;
+export type i18nextProvider = (lng: string) => Promise<{
+    t: (key: string, ns: string) => string;
+}>;
+export type ComponentProvider = (componentName: string) => Promise<AsyncFunctionComponent>;

package/dist/types/core/dummy-comp.d.ts

@@ -0,0 +1,3 @@
+import { LbComponentProps } from "../content/lb-content-block";
+import { JSX } from "react";
+export declare function DummyComp(props: LbComponentProps): Promise<JSX.Element>;

package/dist/types/core/rendering-page-props.d.ts

@@ -0,0 +1,10 @@
+import { ComponentProvider, ContentYamlProvider, i18nextProvider, VisualYamlProvider } from "../content/providers";
+export declare class RenderingPageProps {
+    pageName: string;
+    lng: string;
+    i18nextProvider: i18nextProvider;
+    contentYamlProvider: ContentYamlProvider;
+    visualYamlProvider: VisualYamlProvider;
+    componentProvider: ComponentProvider;
+    constructor(pageName: string, lng: string, i18nextProvider: i18nextProvider, contentYamlProvider: ContentYamlProvider, visualYamlProvider: VisualYamlProvider, componentProvider: ComponentProvider);
+}

package/dist/types/core/rendering-page.d.ts

@@ -0,0 +1,4 @@
+import { JSX } from "react";
+import { RenderingPageProps } from "./rendering-page-props";
+declare function RenderingPage(props: RenderingPageProps): Promise<JSX.Element>;
+export { RenderingPage };

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+import { LbContentImage, LbTranslatedText, LbContentBlock, LbNsContent, LbContentKey, LbVisualComponent, LbRow, LbPageVisual, LbComponentProps } from "./content/lb-content-block";
+import { RenderingPageProps } from "./core/rendering-page-props";
+import { RenderingPage } from "./core/rendering-page";
+import { ContentYamlProvider, VisualYamlProvider, i18nextProvider, AsyncFunctionComponent } from "./content/providers";
+export { LbContentImage, LbTranslatedText, LbContentBlock, LbNsContent, LbContentKey, LbVisualComponent, LbRow, LbPageVisual, LbComponentProps };
+export { RenderingPageProps, RenderingPage };
+export type { ContentYamlProvider, VisualYamlProvider, i18nextProvider, AsyncFunctionComponent };
+export { DummyComp } from "./core/dummy-comp";

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "nodoku-core",
+  "version": "0.1.0",
+  "description": "basic foundation for nodoku static site generator",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "bin": {
+    "nodoku-gen-component-resolver": "./dist/esm/bin/generate-component-resolver.js",
+    "nodoku-gen-content-schema": "./dist/esm/bin/generate-content-schema.js",
+    "nodoku-gen-visual-schema": "./dist/esm/bin/generate-visual-schema.js"
+  },
+  "dependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/mustache": "^4.2.5",
+    "js-yaml": "^4.1.0",
+    "mustache": "^4.2.0"
+  },
+  "peerDependencies": {
+    "@types/react": "^18.3.2",
+    "@types/react-dom": "18.3.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.11",
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "eslint": "^8.56.0",
+    "eslint-config-next": "14.2.3",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "typescript": "^5.5.3",
+    "shx": "^0.3.4"
+  },
+  "scripts": {
+    "dist": "tsc && shx cp -r src/bin/mustache dist/esm/bin/ && shx cp -r schemas dist"
+  }
+}