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

package/renderer.ts

@@ -1,100 +0,0 @@
-import { get, set } from "es-toolkit/compat";
-import handlebars from "handlebars";
-
-import type { GetReturnType, HelperFn, Helpers, MappingScope, Partials, SetOptions, Setter, SetterScope } from "./types.ts";
-import { readonly, textHelpers, utilHelpers } from "./lib.ts";
-
-export class Renderer {
-  #partials: Partials = {};
-  #helpers: Helpers = { ...textHelpers, ...utilHelpers };
-
-  #mapping: { partial: Partials; helper: Helpers } = {
-    partial: this.#partials,
-    helper: this.#helpers,
-  };
-
-  #set<T extends SetterScope>(scope: T, config: Setter<T>, options?: SetOptions): Renderer {
-    if (!config.name) {
-      throw new Error("Name must be non-empty string");
-    }
-
-    const target = get(this.#mapping, scope);
-
-    if (!target) throw new Error("No mapping");
-
-    if (config.name in target && !options?.override) {
-      throw new Error("Can't override");
-    }
-
-    set(target, config.name, config.target);
-
-    return this;
-  }
-
-  private readonly partials: Partials = readonly(this.#partials);
-  private readonly helpers: Helpers = readonly(this.#helpers);
-
-  private get<T extends SetterScope>(scope: T, name: string): GetReturnType<T> {
-    const target = get(this.#mapping, scope);
-
-    if (!target) {
-      throw new Error("!");
-    }
-
-    return get(target, name);
-  }
-
-  private list<T extends `${SetterScope}s`, O extends boolean = false>(
-    scope: T,
-    options?: { full?: O },
-  ): O extends true ? MappingScope[T extends `${infer S}s` ? S : T][] : string[] {
-    const target = get(this.#mapping, scope.slice(0, scope.length - 1));
-
-    if (!target) {
-      throw new Error("No mapping");
-    }
-
-    if (!options?.full) {
-      return Object.keys(target) as any;
-    }
-
-    switch (scope) {
-      case "helpers":
-        return Object.entries(target).map(([name, helper]) => ({
-          name,
-          helper,
-        })) as any;
-
-      case "partials":
-        return Object.entries(target).map(([name, partial]) => ({
-          name,
-          partial,
-        })) as any;
-
-      default:
-        throw new Error("can't find the scope");
-    }
-  }
-
-  public setPartial(name: string, partial: string, options?: SetOptions): Renderer {
-    return this.#set("partial", { target: partial, name }, options);
-  }
-
-  public setHelper(name: string, helper: HelperFn, options?: SetOptions): Renderer {
-    return this.#set("helper", { target: helper, name }, options);
-  }
-
-  public renderString(params: { template: string; data: Record<string, unknown> }): string {
-    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);
-    }
-
-    const compiled = handlebars.compile(params.template);
-
-    return compiled(params.data);
-  }
-}

package/runner.test.ts

@@ -1,24 +0,0 @@
-import test from "node:test";
-import assert from "node:assert";
-import { join } from "node:path";
-
-import { run } from "./runner.ts";
-import { blank1, blank2 } from "./actions/blank.ts";
-
-import type { Config, GeneratorConfig } from "./types.ts";
-
-import { context } from "./actions/context.ts";
-import { loadTemplates } from "./actions/load-templates.ts";
-
-test("simple", async () => {
-  const simple: GeneratorConfig = {
-    name: "simple",
-    description: "description",
-    actions: [blank1, blank2, context(() => ({ kek: Math.random() })), console.log, loadTemplates(join(process.cwd(), "actions"))],
-  };
-
-  const config: Config = { generators: [simple] };
-  const result = await run(config);
-
-  assert(typeof result === "undefined");
-});

package/runner.ts

@@ -1,99 +0,0 @@
-import { Renderer } from "./renderer.ts";
-import * as v from "valibot";
-import type { Action, Config, ExecuteActionParams, GeneratorParams } from "./types.ts";
-import { selectGenerator } from "./actions/select-generator.ts";
-import assert from "node:assert/strict";
-
-export async function runGenerator({ context, generator, renderer }: GeneratorParams): Promise<void> {
-  assert(generator);
-  assert(Array.isArray(generator.actions) && generator.actions.length > 0);
-
-  for (const action of generator.actions) {
-    await executeAction({ action, context, renderer });
-  }
-}
-
-export async function executeAction({ action, context, renderer }: ExecuteActionParams): Promise<void | Action | Action[]> {
-  if (Array.isArray(action)) {
-    for (const action_ of action) {
-      const executed = await action_({ context, renderer });
-      if (!executed) {
-        continue;
-      }
-      await execRecursive(executed, { context, renderer });
-    }
-  }
-
-  if (typeof action !== "function") {
-    return undefined;
-  }
-
-  const executed = await action({ context, renderer });
-
-  if (!executed) {
-    return undefined;
-  }
-
-  return await execRecursive(executed, { context, renderer });
-}
-
-async function execRecursive(executed: Action | Action[], { context, renderer }: Omit<ExecuteActionParams, "action">): Promise<Action | Action[] | void> {
-  if (Array.isArray(executed)) {
-    const executionResults: Action[] = [];
-
-    for (const action of executed) {
-      const result = await executeAction({ action, context, renderer });
-
-      if (result) {
-        if (Array.isArray(result)) {
-          executionResults.push(...result.flat());
-        } else {
-          executionResults.push(result);
-        }
-      }
-    }
-
-    return executionResults;
-  }
-
-  if (typeof executed === "function") {
-    return await executeAction({ action: executed, context, renderer });
-  }
-
-  return undefined;
-}
-
-const ConfigSchema = v.object({
-  generators: v.pipe(
-    v.array(
-      v.object({
-        name: v.string(),
-        description: v.optional(v.string()),
-        actions: v.pipe(v.array(v.any()), v.minLength(1)),
-      }),
-    ),
-    v.minLength(1),
-  ),
-});
-
-export async function run(runConfig: Config): Promise<void> {
-  const config = v.run(ConfigSchema, runConfig);
-
-  if (config.generators.length === 1) {
-    const generator = config.generators[0];
-
-    assert(generator);
-
-    return await runGenerator({
-      context: { errors: [], answers: {} },
-      renderer: new Renderer(),
-      generator,
-    });
-  }
-
-  return await runGenerator({
-    context: { errors: [], answers: {} },
-    renderer: new Renderer(),
-    generator: { name: "select", actions: [selectGenerator(config)] },
-  });
-}