@codeandmoney/jargal 0.0.0-dev.11

package/README.md

@@ -0,0 +1,15 @@
+# @codeandmoney/jargal
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run 
+```
+
+This project was created using `bun init` in bun v1.3.0. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/TODO.md

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

package/actions/ai.ts

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

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

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

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

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

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

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

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

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

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

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

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

package/actions/load-templates.ts

@@ -0,0 +1,107 @@
+import type { ContextAction } from "../types.ts";
+import { readdir, readFile } from "node:fs/promises";
+import path, { resolve } from "node:path";
+
+type TemplateData = { templatePath: string; realativePath: string; templateContent: string };
+
+export function loadTemplates(
+  templatesPath: string,
+  options: {
+    scope?: string;
+    hooks?: { onDataReady?: ((path: string, data: TemplateData) => [path: string, data: TemplateData])[] };
+  },
+): ContextAction<{ templates: Record<string, Map<string, TemplateData>> }> {
+  return async function execute(params) {
+    const record = { ...params.context.templates } as any as Record<string, Map<string, TemplateData>>;
+
+    if (options.scope) {
+      Object.assign(record, { [options.scope]: new Map() });
+    }
+
+    for await (const templatePath of walkDir(templatesPath)) {
+      const realativePath = path.relative(templatesPath, templatePath);
+
+      const contentRaw = await readFile(path.resolve(templatesPath, templatePath));
+      const data: TemplateData = { templateContent: new TextDecoder().decode(contentRaw), templatePath, realativePath };
+
+      if (!options.hooks) {
+        record[options.scope ? options.scope : "templates"]?.set(realativePath, data);
+        continue;
+      }
+
+      if (options.hooks?.onDataReady?.length) {
+        let path_ = realativePath;
+        let data_ = data;
+
+        for (const hook of options.hooks.onDataReady) {
+          [path_, data_] = hook(path_, data_);
+        }
+
+        record[options.scope ? options.scope : "templates"]?.set(path_, data_);
+      }
+    }
+
+    return { templates: record };
+  };
+}
+
+export async function templates<Scope extends string | undefined = undefined>(params: {
+  path: string;
+  scope?: Scope;
+  hooks?: { onDataReady?: ((path: string, data: TemplateData) => [path: string, data: TemplateData])[] };
+}): Promise<
+  (ctx: Record<string, any>) => {
+    templates: Record<Scope extends undefined ? "default" : Scope, Map<string, TemplateData>>;
+  }
+> {
+  let record: undefined | Record<string, Map<string, TemplateData>> = undefined;
+
+  if (params.scope) {
+    record = { [params.scope]: new Map() };
+  } else {
+    record = { default: new Map() };
+  }
+
+  const resolvedPath = resolve(params.path);
+
+  for await (const templatePath of walkDir(resolvedPath)) {
+    const realativePath = path.relative(resolvedPath, templatePath);
+
+    const contentRaw = await readFile(path.resolve(resolvedPath, templatePath));
+    const data: TemplateData = { templateContent: new TextDecoder().decode(contentRaw), templatePath, realativePath };
+
+    if (!params.hooks) {
+      record[params.scope ? params.scope : "default"]?.set(realativePath, data);
+      continue;
+    }
+
+    if (params.hooks?.onDataReady?.length) {
+      let path_ = realativePath;
+      let data_ = data;
+
+      for (const hook of params.hooks.onDataReady) {
+        [path_, data_] = hook(path_, data_);
+      }
+
+      record[params.scope ? params.scope : "default"]?.set(path_, data_);
+    }
+  }
+
+  return function setter(_ctx: Record<string, any>): { templates: Record<string, Map<string, TemplateData>> } {
+    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/modify.ts

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

package/actions/parallel.ts

@@ -0,0 +1,8 @@
+import { executeAction } from "../runner.ts";
+import type { Action } from "../types.ts";
+
+export function parallel(actions: Action[]): Action {
+  return async function execute(params) {
+    await Promise.all(actions.map((action) => executeAction({ action, context: params.context, renderer: params.renderer })));
+  };
+}