@brand-map/generator 0.0.0-dev.14 → 0.1.0

package/src/generator.ts

@@ -0,0 +1,138 @@
+import { mkdir } from "fs/promises";
+import { writeFile } from "fs/promises";
+import path, { dirname } from "path";
+
+import { toMerged } from "es-toolkit";
+
+import { type TemplateData } from "./actions/load-templates";
+import { HandlebarsRenderer } from "./renderer-handlebars";
+import { VentoRenderer } from "./renderer-vento";
+import type { RendererAbstract } from "./types";
+
+export class Genrator<const in out Context = { templates: Record<string, TemplateData>; data: unknown; rendered: { path: string; content: string }[] }> {
+  #context = {
+    templates: {} as Record<string, TemplateData>,
+    data: null as unknown,
+    rendered: [] as { path: string; content: string }[],
+  };
+
+  #renderer: RendererAbstract;
+
+  get context(): Context {
+    return this.#context as any;
+  }
+
+  out: string;
+
+  constructor(config?: ({ engine?: "vento" } | { engine?: "handlebars" }) & { out?: string; cwd?: string }) {
+    this.out = config?.out ?? process.cwd();
+
+    const engine = config?.engine ?? "vento";
+    switch (engine) {
+      case "vento":
+        this.#renderer = new VentoRenderer();
+        break;
+
+      case "handlebars":
+        this.#renderer = new HandlebarsRenderer();
+        break;
+
+      default:
+        throw new Error(`Invalid render engine provided: ${engine}`);
+    }
+  }
+
+  addContext<Setter extends (args: Context) => any>(setter: Setter): Genrator<ReturnType<Setter> & Context>;
+  addContext<Setter extends Record<string, any>>(setter: Setter): Genrator<Setter & Context>;
+  addContext(setter: any) {
+    if (typeof setter === "function") {
+      const context = setter(this.#context);
+      this.#context = toMerged(this.#context as any, context);
+      return this as any;
+    }
+    this.#context = toMerged(this.#context as any, setter);
+    return this as any;
+  }
+
+  async render(
+    renderFn?: (ctx: Context) => {
+      path: string;
+      content: string;
+    }[],
+  ): Promise<void> {
+    switch (true) {
+      case typeof renderFn === "function":
+        {
+          // @ts-expect-error: hard to type
+          const result = renderFn(this.#context);
+          this.#context.rendered.push(...result);
+        }
+        break;
+
+      case !this.#context.data:
+        {
+          for (const template of Object.values(this.#context.templates)) {
+            const content = await this.#renderer.renderString({ template: template.content, data: {} });
+            const savePath = await this.#renderer.renderString({ template: template.relative, data: {} });
+
+            this.#context.rendered.push({ content, path: path.resolve(this.out, savePath) });
+          }
+        }
+        break;
+
+      case Array.isArray(this.#context.data):
+        {
+          for (const data of this.#context.data) {
+            for (const template of Object.values(this.#context.templates)) {
+              const content = await this.#renderer.renderString({ template: template.content, data });
+              const savePath = await this.#renderer.renderString({ template: template.relative, data });
+
+              this.#context.rendered.push({ content, path: path.resolve(this.out, savePath) });
+            }
+          }
+        }
+        break;
+
+      case typeof this.#context.data === "object":
+        {
+          for (const template of Object.values(this.#context.templates)) {
+            const content = await this.#renderer.renderString({ template: template.content, data: this.#context.data });
+            const savePath = await this.#renderer.renderString({ template: template.relative, data: this.#context.data });
+
+            this.#context.rendered.push({ content, path: path.resolve(this.out, savePath) });
+          }
+        }
+        break;
+
+      default: {
+        console.log(
+          "Data to render in `.context.data` is not object or array and you didnt provide `renderFn` to `render()` call. So I cant render your stuff...",
+        );
+      }
+    }
+  }
+
+  async write(
+    callback?: (params: { path: string; content: string; writeFn: (params: { path: string; content: string }) => Promise<void> }) => void | Promise<void>,
+  ): Promise<void> {
+    if (typeof callback === "function") {
+      for (const renderConfig of this.#context.rendered) {
+        await callback({ ...renderConfig, writeFn });
+      }
+      return;
+    }
+
+    for (const renderConfig of this.#context.rendered) {
+      await writeFn(renderConfig);
+    }
+  }
+}
+
+async function writeFn({ path, content }: { path: string; content: string }): Promise<void> {
+  try {
+    await mkdir(dirname(path), { recursive: true });
+  } catch (error) {
+    console.error({ path, content, error });
+  }
+  await writeFile(path, new TextEncoder().encode(content), {});
+}

package/{lib.ts → src/lib.ts}

@@ -12,12 +12,12 @@ import {
   snakeCase,
   trainCase,
 } from "change-case";
-import { titleCase } from "title-case";
 import { deburr, lowerFirst, startCase, trim } from "es-toolkit";
+import { titleCase } from "title-case";
 
-import type { ActionHooks, ActionHooksChanges, ActionHooksFailures, TextHelpers } from "./types.ts";
+import type { TextHelpers, ActionHooks, ActionHooksChanges, ActionHooksFailures } from "./types";
 
-export const textHelpers: TextHelpers = {
+export const textHelpers = {
   upperCase: (str) => str.toUpperCase(),
   lowerCase: (str) => str.toLowerCase(),
   camelCase: (str) => camelCase(str),
@@ -40,7 +40,7 @@ export const textHelpers: TextHelpers = {
   pascalSnakeCase: (str) => pascalSnakeCase(str),
   trainCase: (str) => trainCase(str),
   trim: (str) => trim(str),
-};
+} satisfies TextHelpers;
 
 export class Hooks implements ActionHooks {
   onComment(message: string) {

package/src/renderer-handlebars.ts

@@ -0,0 +1,27 @@
+import handlebars from "handlebars";
+
+import { textHelpers, utilHelpers } from "./lib";
+import { RendererAbstract, type Helpers, type Partials } from "./types";
+
+export class HandlebarsRenderer extends RendererAbstract {
+  #partials: Partials = {};
+  #helpers: Helpers = { ...textHelpers, ...utilHelpers };
+
+  constructor() {
+    super();
+
+    for (const [name, helper] of Object.entries(this.#helpers)) {
+      handlebars.registerHelper(name, helper);
+    }
+
+    for (const [name, partial] of Object.entries(this.#partials)) {
+      handlebars.registerPartial(name, partial);
+    }
+  }
+
+  public override renderString(params: { template: string; data: Record<string, unknown> }): Promise<string> {
+    const compiled = handlebars.compile(params.template);
+
+    return Promise.resolve(compiled(params.data));
+  }
+}

package/src/renderer-vento.ts

@@ -0,0 +1,21 @@
+import vento from "ventojs";
+
+import { textHelpers } from "./lib";
+import { RendererAbstract } from "./types";
+
+export class VentoRenderer extends RendererAbstract {
+  #env = vento();
+
+  constructor() {
+    super();
+
+    for (const [key, fn] of Object.entries(textHelpers)) {
+      Object.assign(this.#env.filters, { [key]: fn });
+    }
+  }
+
+  public override async renderString(params: { template: string; data: Record<string, unknown> }): Promise<string> {
+    const result = await this.#env.runString(params.template, params.data);
+    return result.content;
+  }
+}

package/{types.ts → src/types.ts}

@@ -1,4 +1,6 @@
-import type { Renderer } from "./renderer.ts";
+export abstract class RendererAbstract {
+  public abstract renderString(params: { template: string; data: object }): Promise<string>;
+}
 
 export interface Config {
   generators: GeneratorConfig[];
@@ -15,20 +17,20 @@ export type DeepReadonly<T> = {
 
 export interface GeneratorParams {
   context: Context;
-  renderer: Renderer;
+  renderer: RendererAbstract;
   generator: GeneratorConfig;
   hooks?: ActionHooks;
 }
 
 export interface ActionParams<Ctx extends object = {}> {
   context: Context<Ctx>;
-  renderer: Renderer;
+  renderer: RendererAbstract;
   hooks?: ActionHooks;
 }
 
 export interface ExecuteActionParams<Ctx extends object = {}> {
   context: Context<Ctx>;
-  renderer: Renderer;
+  renderer: RendererAbstract;
   action: Action;
 }
 

package/tsconfig.json

@@ -10,7 +10,7 @@
 
     // Bundler mode
     "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
+    "allowImportingTsExtensions": false,
     "verbatimModuleSyntax": true,
     "noEmit": true,
 

package/TODO.md

@@ -1,2 +0,0 @@
-1. Write tests
-2. Document

package/actions/ai.ts

@@ -1,7 +0,0 @@
-import type { Action } from "../types.ts";
-
-export function ai(): Action {
-  return function execute(_params) {
-    throw new Error("Action is not implemented");
-  };
-}

package/actions/answer.ts

@@ -1,7 +0,0 @@
-import type { Action } from "../types.ts";
-
-export function answer(): Action {
-  return function execute(_params) {
-    throw new Error("Action is not implemented");
-  };
-}

package/actions/blank.ts

@@ -1,55 +0,0 @@
-import type { Action } from "../types.ts";
-
-export const blank1: Action = () => {
-  console.log("blank1:", "1");
-
-  return function execute(_params) {
-    console.log("blank1:", "2");
-
-    return function action() {
-      console.log("blank1:", "3");
-    };
-  };
-};
-
-export const blank2: Action = () => {
-  console.log("blank2:", 1);
-
-  return function execute(_params) {
-    console.log("blank2:", 2);
-
-    return [
-      function action() {
-        console.log("blank2:", 3);
-      },
-
-      function action() {
-        console.log("blank2:", 4);
-        return [() => console.log("blank2:", 4, 1), () => console.log("blank2:", 4, 2), () => console.log("blank2:", 4, 3)];
-      },
-    ];
-  };
-};
-
-export const blank3: Action = () => {
-  console.log("blank3:", 1);
-
-  return function execute(_params) {
-    console.log("blank3:", 2);
-  };
-};
-
-export function blankRecursive(depth = 10): Action {
-  return () => (Math.random() > 0.5 ? recursive(depth) : [recursive(depth)]);
-}
-
-function recursive(depth: number): Action {
-  if (depth > 0) {
-    return () => {
-      console.log(depth);
-      return [blank1, blank2, blank3, recursive(depth - 1)];
-    };
-  }
-
-  return () => console.log(0);
-}

package/actions/combine.ts

@@ -1,14 +0,0 @@
-import { executeAction } from "../runner.ts";
-import type { Action } from "../types.ts";
-
-export function combine(...actions: Action[]): Action {
-  return async function execute(params) {
-    for (const action of actions) {
-      await executeAction({
-        action,
-        context: params.context,
-        renderer: params.renderer,
-      });
-    }
-  };
-}

package/actions/config.ts

@@ -1,7 +0,0 @@
-import type { Action } from "../types.ts";
-
-export function config(): Action {
-  return function execute(_params) {
-    throw new Error("Action is not implemented");
-  };
-}

package/actions/context/context.ts

@@ -1,44 +0,0 @@
-import type { BaseIssue, BaseAction, ErrorMessage, Context, OutputContext, BaseContext } from "../../types/index.ts";
-
-/**
- * Context issue interface.
- */
-export interface ContextIssue extends BaseIssue<unknown> {
-  /**
-   * The issue kind.
-   */
-  readonly kind: "action";
-  /**
-   * The issue type.
-   */
-  readonly type: "string";
-}
-
-/**
- * Context schema interface.
- */
-export interface ContextAction<Config extends Record<string, any> | undefined, Output extends Record<string, any>> extends BaseAction<Config, Output> {
-  readonly config: Config;
-
-  /**
-   * The expected property.
-   */
-  readonly expects: "string";
-}
-
-export type ContextActionConfig = {
-  callback: any;
-};
-
-// export function context<Ctx extends Record<string, any>>(config?: ContextActionConfig): ContextAction<ContextActionConfig, Ctx>;
-// export function context<Ctx extends undefined = undefined>(config: ContextActionConfig): ContextAction<ContextActionConfig, {}>;
-export function context<Ctx extends BaseContext, R extends BaseContext>(fn: (ctx: Ctx) => OutputContext<R>): BaseAction<Ctx & R> {
-  // ContextAction<ContextActionConfig, Ctx>
-  return {
-    kind: "action",
-    "~run"(context) {
-      const updated = fn(context);
-      return updated as any;
-    },
-  };
-}

package/actions/context.ts

@@ -1,10 +0,0 @@
-import { merge } from "es-toolkit";
-import { readonly } from "../lib.ts";
-import type { Action, ContextAction } from "../types.ts";
-
-export function context(callback: ContextAction): Action {
-  return async function execute(params) {
-    const newContext = await callback(readonly(params));
-    merge(params.context, newContext);
-  };
-}

package/actions/echo.ts

@@ -1,19 +0,0 @@
-import type { Action, ActionParams } from "../types.ts";
-
-export function echo(arg?: string | ((params: ActionParams) => void)): Action {
-  return function execute(params) {
-    switch (typeof arg) {
-      case "function":
-        arg(params);
-        break;
-
-      case "string":
-        console.log(arg);
-        break;
-
-      default:
-        console.log("Hello, World!");
-        break;
-    }
-  };
-}

package/actions/exports.ts

@@ -1,9 +0,0 @@
-export { context } from "./context.ts";
-export { prompt } from "./prompt.ts";
-export { parallel } from "./parallel.ts";
-export { write } from "./write.ts";
-export { combine } from "./combine.ts";
-export { echo } from "./echo.ts";
-export { validateAnswers } from "./validate-answers.ts";
-export { loadTemplates } from "./load-templates.ts";
-export { renderTemplate } from "./render-template.ts";

package/actions/jargal-context.ts

@@ -1,21 +0,0 @@
-import { merge } from "es-toolkit";
-import { readonly } from "../lib.ts";
-import type { Action, ContextAction } from "../types.ts";
-
-export async function contextAsync<Callback extends (...arg: any[]) => any>(callback: Callback): Promise<(ctx: Record<string, any>) => ReturnType<Callback>> {
-  const newContext = callback();
-
-  return function execute(ctx) {
-    // merge(params.context, newContext);
-    return newContext;
-  };
-}
-
-export function context<Callback extends (...arg: any[]) => any>(callback: Callback): (ctx: Record<string, any>) => ReturnType<Callback> {
-  const newContext = callback();
-
-  return function execute(ctx) {
-    // merge(params.context, newContext);
-    return newContext;
-  };
-}

package/actions/jargal-templates.ts

@@ -1,82 +0,0 @@
-import assert from "node:assert";
-import { readdir, readFile } from "node:fs/promises";
-import path, { resolve } from "node:path";
-
-export type TemplateData = {
-  templatePath: string;
-  savePath: string;
-  templateContent: string;
-  metadata?: Record<string, any>;
-};
-
-export type TemplatesMap = Record<string, TemplateData>;
-
-type Templates<Key extends string> = { templates: Record<Key, TemplatesMap> };
-
-export async function templates<Scope extends string | undefined = undefined>(params: {
-  path: string;
-  scope?: Scope;
-  engine?: "handlebars";
-  hooks?: {
-    onDataReady?: ((path: string, data: TemplateData) => [path: string, data: TemplateData])[];
-  };
-}): Promise<(ctx: Record<string, any>) => Templates<Scope extends undefined ? "default" : Scope>> {
-  const engine = params?.engine ?? "handlebars";
-  const removeExtension = engine === "handlebars" ? ".hbs" : "";
-  const scopeKey = params.scope ? params.scope : "default";
-
-  const record = { [scopeKey]: {} } as Record<string, TemplatesMap>;
-
-  const resolvedPath = resolve(params.path);
-
-  for await (const templatePath of walkDir(resolvedPath)) {
-    if (path.basename(templatePath).startsWith("_")) {
-      continue;
-    }
-
-    const savePath = path.relative(resolvedPath, templatePath).replace(removeExtension, "");
-
-    const contentRaw = await readFile(path.resolve(resolvedPath, templatePath));
-    const data: TemplateData = {
-      templateContent: new TextDecoder().decode(contentRaw),
-      templatePath,
-      savePath,
-    };
-
-    if (!params.hooks) {
-      assert(record[scopeKey]);
-      Object.assign(record[scopeKey], { [savePath]: data });
-      continue;
-    }
-
-    if (params.hooks?.onDataReady?.length) {
-      let path_ = savePath;
-      let data_ = data;
-
-      for (const hook of params.hooks.onDataReady) {
-        [path_, data_] = hook(path_, data_);
-      }
-
-      assert(record[scopeKey]);
-      Object.assign(record[scopeKey], { [path_]: data_ });
-    }
-  }
-
-  return function setter(_ctx: Record<string, any>) {
-    return { templates: record };
-  };
-}
-
-async function* walkDir(dir: string): AsyncGenerator<string, void, void> {
-  const entries = await readdir(dir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const templatePath = path.join(dir, entry.name);
-
-    if (entry.isDirectory()) {
-      yield* walkDir(templatePath);
-    } else if (entry.isFile()) {
-      yield templatePath;
-    }
-  }
-}

package/actions/jargal-write.ts

@@ -1,46 +0,0 @@
-import { access, mkdir, rm, writeFile } from "node:fs/promises";
-
-import assert from "node:assert";
-import { dirname } from "node:path";
-import type { TemplateData } from "./jargal-templates";
-
-export type WriteActionConfig = {
-  destination: string;
-  mode?: "force" | "skip-if-exists";
-} & TemplateData;
-
-export async function write({ destination, templateContent, mode }: WriteActionConfig): Promise<void> {
-  if (!templateContent) {
-    return;
-  }
-
-  assert(destination, "must provide `destination`");
-  assert(templateContent, "must provide `templateContent`");
-
-  await mkdir(dirname(destination), { recursive: true });
-
-  let doesExist = await fileExists(destination);
-
-  if (doesExist && mode === "force") {
-    await rm(destination, { recursive: true, force: true });
-    doesExist = false;
-  }
-
-  if (doesExist && mode !== "skip-if-exists") {
-    throw `File already exists\n -> ${destination}`;
-  }
-
-  if (doesExist && mode === "skip-if-exists") {
-    console.info(`[SKIPPED] ${destination} (exists)`);
-    return;
-  }
-
-  await writeFile(destination, new TextEncoder().encode(templateContent));
-}
-
-function fileExists(destination: string) {
-  return access(destination).then(
-    () => true,
-    () => false,
-  );
-}