nodoku-core 0.1.0 → 0.1.1

package/dist/esm/bin/generate-component-default-theme.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "path";
+import yaml from "js-yaml";
+async function generateComponentDefaultTheme() {
+    console.log("generating default theme");
+    const dir = path.resolve("./dist/esm/components");
+    const dirSchema = path.resolve("./dist/schemas/components");
+    const components = fs.readdirSync(dir);
+    console.log("components", components);
+    Promise.all(components.map(async (compo) => {
+        const defaultTheme = (await import(`file:${path.resolve(dir, compo, compo + "-theme.js")}`)).default;
+        console.log("defaultTheme", defaultTheme);
+        const yamlContent = yaml.dump(defaultTheme, {
+            indent: 4,
+            lineWidth: 5000
+        });
+        console.log("yaml default theme", compo, yamlContent);
+        fs.writeFileSync(path.resolve(dirSchema, compo, "default-theme.yml"), yamlContent);
+        return null;
+    }));
+}
+await generateComponentDefaultTheme();

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

@@ -1,9 +1,9 @@
 #!/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";
+import { loadManifestsFromFolder } from "./manifest-loader.js";
 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
@@ -11,94 +11,45 @@ register('./import-load-hooks.js', import.meta.url);
  * 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;
-}
+const template = (await import("./mustache/component-resolver.ts.hbs")).default;
 class TemplateView {
-    modules = new Map();
-    names = new Map();
+    modules = [];
+    comps = [];
 }
-function calculateTemplateView(dir = undefined) {
-    if (!dir) {
-        dir = path.resolve();
+function calculateTemplateView(dirNodeModules = undefined) {
+    if (!dirNodeModules) {
+        dirNodeModules = `${path.resolve()}/node_modules`;
     }
-    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, []);
-        }
+    const manifests = loadManifestsFromFolder(dirNodeModules);
+    const view = new TemplateView();
+    manifests.forEach((m, k) => {
+        let prefix = "";
         if (m.namespace) {
-            tv.modules.get(m.moduleName).push(m.namespace);
-            m.components.forEach((cd, cn) => {
-                tv.names.set(cn, `${m.namespace}.${cd.implementation}`);
-            });
+            view.modules.push({ module: m.moduleName, comps: [m.namespace] });
+            prefix = `${m.namespace}.`;
         }
         else {
-            m.components.forEach((cd, cn) => {
-                tv.modules.get(m.moduleName).push(cd.implementation);
-                tv.names.set(cn, cd.implementation);
-            });
+            view.modules.push({ module: m.moduleName, comps: Array.from(m.components.entries()).map(c => c[1].implementation) });
         }
+        m.components.forEach((cd, cn) => {
+            let nb;
+            if (typeof cd.numBlocks == "string") {
+                nb = `"${cd.numBlocks}"`;
+            }
+            else {
+                nb = `${cd.numBlocks}`;
+            }
+            view.comps.push({ name: cn, impl: `${prefix}${cd.implementation}`, defaultThemeFile: "./" + path.relative(path.resolve("."), path.resolve("./schemas", m.moduleName, cd.defaultThemeFile)).replaceAll("\\", "/"), numBlocks: nb });
+        });
     });
-    return tv;
+    return view;
 }
 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] }; })
-    };
+    const view = calculateTemplateView();
     console.log("view", JSON.stringify(view));
     const output = Mustache.render(template, view);
     const fileName = `${dir}/${src}/nodoku-component-resolver.ts`;

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

@@ -10,7 +10,7 @@ register('./import-load-hooks.js', import.meta.url);
  * 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 template = (await import("./mustache/content-schema.json.hbs")).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);

package/dist/esm/bin/{generate-visual-schema.js → generate-skin-schema.js}

@@ -1,9 +1,9 @@
 #!/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";
+import { loadManifestsFromFolder } from "./manifest-loader.js";
 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
@@ -11,79 +11,66 @@ register('./import-load-hooks.js', import.meta.url);
  * 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;
-}
+const template = (await import("./mustache/visual-schema.json.hbs")).default;
 class TemplateView {
     components = new Map();
 }
 function calculateTemplateView(schemaDestinationDir, dirNodeModules = undefined) {
     if (!dirNodeModules) {
-        dirNodeModules = `${path.resolve()}/node_modules`;
+        dirNodeModules = path.resolve("./node_modules");
     }
-    const components = loadComponents(dirNodeModules);
+    const components = loadManifestsFromFolder(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 themeSchema = resolveSchema(schemaDestinationDir, m.moduleName, moduleDir, cd.themeSchema, dirNodeModules);
+            const optionsSchema = resolveSchema(schemaDestinationDir, m.moduleName, moduleDir, cd.optionsSchema, dirNodeModules);
+            tv.components.set(cn, { themeSchema: themeSchema, optionsSchema: optionsSchema });
+            /*
+             * copy default-theme.yml
+            */
+            const compSchema = cd.themeSchema;
+            const moduleSchemaFile = path.resolve(stripTrailingSlash(moduleDir), stripLeadingSlash(compSchema));
+            const compDefaultYaml = cd.defaultThemeFile;
+            // const moduleDefaultYamlFile = path.resolve(path.dirname(moduleSchemaFile), stripLeadingSlash(compDefaultYaml));
+            const moduleDefaultYamlFile = path.resolve(stripTrailingSlash(moduleDir), stripLeadingSlash(compDefaultYaml));
+            let stat = undefined;
+            try {
+                stat = fs.statSync(moduleDefaultYamlFile);
+                console.log("defaultYamlFilePath", moduleDefaultYamlFile);
+                if (stat.isFile()) {
+                    let destSchemaFile = path.resolve(m.moduleName, compSchema);
+                    console.log("compSchema", compSchema);
+                    const dest = path.resolve(schemaDestinationDir, themeSchema);
+                    const yamlFileName = path.basename(moduleDefaultYamlFile);
+                    console.log("copying default-theme.yml", yamlFileName, schemaDestinationDir, destSchemaFile, moduleDefaultYamlFile, dest, path.dirname(dest));
+                    fs.copyFile(moduleDefaultYamlFile, path.resolve(path.dirname(dest), yamlFileName), (err) => { });
+                }
+            }
+            catch (e) {
+                console.log("defaultYamlFilePath file not found ", moduleDefaultYamlFile);
+            }
         });
     });
     const compSchemas = [];
     let i = 0;
     tv.components.forEach((v, k) => {
-        compSchemas.push({ name: k, schema: v, isLast: i == tv.components.size - 1 });
+        compSchemas.push({ name: k, schema: v.themeSchema, options: v.optionsSchema, isLast: i == tv.components.size - 1 });
         i++;
     });
     return { components: compSchemas };
 }
+function resolveSchema(schemaDestinationDir, moduleName, moduleDir, schemaFileLoc, dirNodeModules) {
+    if (!schemaFileLoc) {
+        return undefined;
+    }
+    const { content, dest } = readSchema(schemaDestinationDir, moduleName, moduleDir, schemaFileLoc);
+    const resolvedContent = resolveRefsInSchema(content, moduleName, dirNodeModules, schemaDestinationDir, schemaFileLoc);
+    const schemaFile = writeSchema(dest, resolvedContent);
+    const res = schemaFile.startsWith(schemaDestinationDir) ? schemaFile.replace(stripTrailingSlash(schemaDestinationDir), ".") : schemaFile;
+    return res;
+}
 function resolveRefsInSchema(schemaFileContent, moduleName, dirNodeModules, schemaDestinationDir, schemaFileRelativeToModuleDir) {
     const regex = /\s*"\$ref": "(.*)"/;
     const refs = [];
@@ -143,10 +130,11 @@ function resolveRef(ref, moduleName, dirNodeModules, schemaDestinationDir, schem
     console.log("returning ref", ref);
     return ref;
 }
-function readSchema(schemaDestinationDir, moduleName, moduleDir, compSchema) {
-    const moduleSchemaFile = `${stripTrailingSlash(moduleDir)}/${stripLeadingSlash(compSchema)}`;
+function readSchema(schemaDestinationDir, moduleName, moduleDir, schemaFileLoc) {
+    // const moduleSchemaFile = `${stripTrailingSlash(moduleDir)}/${stripLeadingSlash(schemaFileLoc)}`;
+    const moduleSchemaFile = path.resolve(moduleDir, schemaFileLoc);
     console.log("module dir", moduleDir);
-    let destSchemaFile = `${moduleName}/${stripLeadingSlash(compSchema)}`;
+    let destSchemaFile = `${moduleName}/${stripLeadingSlash(schemaFileLoc)}`;
     const dest = `${schemaDestinationDir}/${destSchemaFile}`;
     const moduleSchemaFilePath = moduleSchemaFile.replaceAll("/", "\\");
     const stat = fs.statSync(moduleSchemaFilePath);
@@ -174,15 +162,15 @@ function stripTrailingSlash(path) {
     return path;
 }
 function stripLeadingSlash(path) {
-    if (path.startsWith("/")) {
+    if (path && path.startsWith("/")) {
         return path.substring(1);
     }
-    else if (path.startsWith("./")) {
+    else if (path && path.startsWith("./")) {
         return path.substring(2);
     }
     return path;
 }
-export function generateVisualSchema() {
+export function generateSkinSchema() {
     const args = process.argv.slice(2);
     const dir = path.resolve();
     const schemaSrc = args[0] ? args[0] : "./schemas";
@@ -197,4 +185,4 @@ export function generateVisualSchema() {
         console.log(`${fileName}: File created!`);
     });
 }
-generateVisualSchema();
+generateSkinSchema();

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

@@ -10,7 +10,7 @@ export async function resolve(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")) {
+    if (url.endsWith(".hbs")) {
         const prefix = path.resolve("./");
         const filePath = nodeUrl.fileURLToPath(url);
         const file = await open(filePath);

package/dist/esm/bin/manifest-loader.js

@@ -0,0 +1,49 @@
+import { ComponentDef, Manifest } from "./manifest.js";
+import fs from "node:fs";
+import path from "path";
+export function loadManifestsFromFolder(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 moduleDir = path.resolve(dir, f);
+        const stat = fs.statSync(moduleDir);
+        if (stat.isFile()) {
+            if (f == "nodoku.manifest.json") {
+                const manifest = new Manifest(moduleName, moduleDir);
+                console.log("found manifest ", `${dir}/${f}`, "reading...");
+                let json;
+                if (stat.isSymbolicLink()) {
+                    json = JSON.parse(fs.readlinkSync(`${dir}/nodoku.manifest.json`).toString());
+                }
+                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, v.optionsFile, v.defaultThemeFile, v.numBlocks));
+                });
+                return manifest;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/esm/bin/manifest.js

@@ -0,0 +1,24 @@
+export class ComponentDef {
+    implementation;
+    themeSchema;
+    optionsSchema;
+    defaultThemeFile;
+    numBlocks;
+    constructor(componentImplementation, componentSchema, optionsSchema, defaultThemeFile, numBlocks) {
+        this.implementation = componentImplementation;
+        this.themeSchema = componentSchema;
+        this.optionsSchema = optionsSchema;
+        this.defaultThemeFile = defaultThemeFile;
+        this.numBlocks = numBlocks;
+    }
+}
+export class Manifest {
+    moduleName;
+    moduleDir;
+    namespace = undefined;
+    components = new Map();
+    constructor(moduleName, moduleDir) {
+        this.moduleName = moduleName;
+        this.moduleDir = moduleDir;
+    }
+}

package/dist/esm/bin/mustache/component-resolver.ts.hbs

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

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

@@ -0,0 +1,132 @@
+{
+  "description": "Landing buddy content page schema",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "Link": {
+      "type": "string",
+      "pattern": "{{{linkRegexPattern}}}"
+    },
+    "ClickableText": {
+      "oneOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "text": {
+              "type": "string"
+            },
+            "link": {
+              "$ref": "#/definitions/Link"
+            }
+          }
+        }
+      ]
+    },
+    "Image": {
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "title": {
+              "type": "string"
+            },
+            "url": {
+              "type": "string"
+            },
+            "alt": {
+              "type": "string"
+            },
+            "link": {
+              "$ref": "#/definitions/Link"
+            }
+          },
+          "required": [
+            "url"
+          ]
+        },
+        {
+          "type": "string"
+        }
+      ]
+    },
+    "ContentBlock": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "title": {
+          "$ref": "#/definitions/ClickableText"
+        },
+        "subTitle": {
+          "$ref": "#/definitions/ClickableText"
+        },
+        "h3": {
+          "$ref": "#/definitions/ClickableText"
+        },
+        "h4": {
+          "$ref": "#/definitions/ClickableText"
+        },
+        "h5": {
+          "$ref": "#/definitions/ClickableText"
+        },
+        "h6": {
+          "$ref": "#/definitions/ClickableText"
+        },
+        "footer": {
+          "$ref": "#/definitions/ClickableText"
+        },
+        "images": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Image"
+          }
+        },
+        "paragraphs": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/ClickableText"
+          },
+          "additionalItems": false
+        },
+        "bgImage": {
+          "$ref": "#/definitions/Image"
+        },
+        "namespace": {
+          "type": "string"
+        },
+        "tags": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "attributes": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          }
+        }
+
+      },
+      "additionalItems": false,
+      "additionalProperties": false
+    },
+    "SectionBlock": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/ContentBlock"
+      },
+      "additionalItems": false,
+      "additionalProperties": false
+    }
+  },
+  "type": "array",
+  "items": {
+    "$ref": "#/definitions/ContentBlock"
+  },
+  "additionalItems": false,
+  "additionalProperties": false
+}