@codeandmoney/jargal 0.0.0-dev.11

package/lib.ts

@@ -0,0 +1,101 @@
+import {
+  camelCase,
+  capitalCase,
+  constantCase,
+  dotCase,
+  kebabCase,
+  noCase,
+  pascalCase,
+  pascalSnakeCase,
+  pathCase,
+  sentenceCase,
+  snakeCase,
+  trainCase,
+} from "change-case";
+import { titleCase } from "title-case";
+import { deburr, lowerFirst, startCase, trim } from "es-toolkit";
+
+import type { ActionHooks, ActionHooksChanges, ActionHooksFailures, TextHelpers } from "./types.ts";
+
+export const textHelpers: TextHelpers = {
+  upperCase: (str) => str.toUpperCase(),
+  lowerCase: (str) => str.toLowerCase(),
+  camelCase: (str) => camelCase(str),
+  snakeCase: (str) => snakeCase(str),
+  dotCase: (str) => dotCase(str),
+  pathCase: (str) => pathCase(str),
+  sentenceCase: (str) => sentenceCase(str),
+  constantCase: (str) => constantCase(str),
+  titleCase: (str) => titleCase(str),
+  kebabCase: (str) => kebabCase(str),
+  dashCase: (str) => kebabCase(str),
+  kabobCase: (str) => kebabCase(str),
+  pascalCase: (str) => pascalCase(str),
+  properCase: (str) => pascalCase(str),
+  deburr: (str) => deburr(str),
+  lowerFirst: (str) => lowerFirst(str),
+  startCase: (str) => startCase(str),
+  noCase: (str) => noCase(str),
+  capitalCase: (str) => capitalCase(str),
+  pascalSnakeCase: (str) => pascalSnakeCase(str),
+  trainCase: (str) => trainCase(str),
+  trim: (str) => trim(str),
+};
+
+export class Hooks implements ActionHooks {
+  onComment(message: string) {
+    console.info(message);
+  }
+
+  onSuccess(change: ActionHooksChanges) {
+    console.info(change);
+  }
+
+  onFailure(failure: ActionHooksFailures) {
+    console.error(failure);
+  }
+}
+
+const ReadOnlyProxyDescriptor = {
+  get<T extends object>(target: T, key: keyof T & (string & {})): any {
+    const value = target[key];
+
+    if (!isObject(value)) {
+      return value;
+    }
+
+    return readonly(value);
+  },
+
+  set(_target: object, _key: string) {
+    throw new ReadOnlyProxyWriteError("Cannot write on read-only proxy");
+  },
+
+  deleteProperty(_target: object, _key: string) {
+    throw new ReadOnlyProxyWriteError("Cannot delete on read-only proxy");
+  },
+};
+
+function isObject(thing: unknown) {
+  return thing !== null && typeof thing === "object";
+}
+
+class ReadOnlyProxyWriteError extends Error {
+  override name = "ReadOnlyProxyWriteError";
+}
+
+// Create a read-only proxy over an object.
+// Sub-properties that are objects also return read-only proxies.
+export function readonly<T extends object>(target: T) {
+  return new Proxy<T>(target, ReadOnlyProxyDescriptor);
+}
+
+export const utilHelpers = {
+  isdefined: function (value: unknown) {
+    return value !== undefined;
+  },
+
+  is: function (left: unknown, right: unknown) {
+    return left === right;
+  },
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@codeandmoney/jargal",
+  "version": "0.0.0-dev.11",
+  "description": "Renderer",
+  "license": "MIT",
+  "author": "Code & Money Team",
+  "contributors": [
+    {
+      "name": "Alexey Sokolov",
+      "email": "alexey@codeandmoney.com",
+      "url": "https://codeandmoney.com"
+    }
+  ],
+  "exports": {
+    "./old": "./exports.ts",
+    ".": "./jargal.ts",
+    "./types": "./types.ts",
+    "./actions": "./actions/exports.ts",
+    "./renderer": "./renderer.ts"
+  },
+  "dependencies": {
+    "change-case": "^5.4.4",
+    "enquirer": "^2.4.1",
+    "es-toolkit": "^1.40.0",
+    "handlebars": "^4.7.8",
+    "title-case": "^4.3.2",
+    "valibot": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.0",
+    "@types/node": "^24.7.2"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/renderer.ts

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,99 @@
+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)] },
+  });
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

package/types.ts

@@ -0,0 +1,91 @@
+import type { Renderer } from "./renderer.ts";
+
+export interface Config {
+  generators: GeneratorConfig[];
+}
+
+export type Context<Ctx extends object = {}> = Ctx & {
+  answers: Record<string, string | boolean | (string | boolean)[]>;
+  errors: Error[];
+};
+
+export type DeepReadonly<T> = {
+  readonly [Key in keyof T]: T[Key] extends any[] ? T[Key] : T[Key] extends object ? DeepReadonly<T[Key]> : T[Key];
+};
+
+export interface GeneratorParams {
+  context: Context;
+  renderer: Renderer;
+  generator: GeneratorConfig;
+  hooks?: ActionHooks;
+}
+
+export interface ActionParams<Ctx extends object = {}> {
+  context: Context<Ctx>;
+  renderer: Renderer;
+  hooks?: ActionHooks;
+}
+
+export interface ExecuteActionParams<Ctx extends object = {}> {
+  context: Context<Ctx>;
+  renderer: Renderer;
+  action: Action;
+}
+
+export type ContextAction<Ctx extends object = {}> = (params: DeepReadonly<ExecuteActionParams<Ctx>>) => Partial<Context<Ctx>> | Promise<Partial<Context<Ctx>>>;
+
+export interface GeneratorConfig {
+  name: string;
+  description?: string;
+  actions: Action[];
+}
+
+export type HelperFn = (str: string) => string;
+
+export interface TextHelpers extends Record<string, HelperFn> {}
+
+export type Action<Ctx extends object = {}> = (params: ActionParams<Ctx>) => void | Action | Action[] | Promise<void | Action | Action[]>;
+
+export interface ActionHooksFailures {
+  path: string;
+  error: string;
+  message?: string;
+}
+
+export interface ActionHooksChanges {
+  path: string;
+}
+
+export interface ActionHooks {
+  onComment?: (msg: string) => void;
+  onSuccess?: (change: ActionHooksChanges) => void;
+  onFailure?: (failure: ActionHooksFailures) => void;
+}
+
+export type SetterScope = "helper" | "partial";
+
+export interface SetOptions {
+  override?: boolean;
+}
+
+export interface MappingScope {
+  helper: { name: string; target: HelperFn };
+  partial: { name: string; target: string };
+}
+
+interface Mapping {
+  helper: HelperFn;
+  partial: string;
+}
+
+type GetSetterType<Key extends SetterScope> = Mapping[Key];
+
+export interface Setter<T extends SetterScope> {
+  target: GetSetterType<T>;
+  name: string;
+}
+
+export type GetReturnType<T extends SetterScope> = Mapping[T];
+
+export interface Partials extends Record<string, string> {}
+export interface Helpers extends Record<string, any> {}