@codeandmoney/jargal 0.0.0-dev.11

package/actions/pipe.ts

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

package/actions/prompt.ts

@@ -0,0 +1,134 @@
+import enquirer from "enquirer";
+import type { Action } from "../types.ts";
+import { EventEmitter } from "node:events";
+
+export function prompt(questions: PromptOptions | PromptOptions[]): Action {
+  return async function executePrompts(params) {
+    const answers = await enquirer.prompt(questions);
+
+    if (!params.context.answers) {
+      Object.assign(params.context, { answers: {} });
+    }
+
+    for (const [key, value] of Object.entries(answers)) {
+      Object.assign(params.context.answers, { [key]: value });
+    }
+  };
+}
+
+// NOTE: Stupid enquirer doesn't export types at all!!!
+//       So, I, being stupid dev, just copied them to get better inference
+
+type PromptTypes =
+  | "autocomplete"
+  | "editable"
+  | "form"
+  | "multiselect"
+  | "select"
+  | "survey"
+  | "list"
+  | "scale"
+  | "confirm"
+  | "input"
+  | "invisible"
+  | "list"
+  | "password"
+  | "text"
+  | "numeral"
+  | "snippet"
+  | "sort";
+
+interface BasePromptOptions {
+  name: string | (() => string);
+  type: PromptTypes | (() => PromptTypes);
+  message: string | (() => string) | (() => Promise<string>);
+  prefix?: string;
+  initial?: any;
+  required?: boolean;
+  enabled?: boolean | string;
+  disabled?: boolean | string;
+  format?(value: string): string | Promise<string>;
+  result?(value: string): string | Promise<string>;
+  skip?: ((state: object) => boolean | Promise<boolean>) | boolean;
+  validate?(value: string): boolean | string | Promise<boolean | string>;
+  onSubmit?(name: string, value: any, prompt: BasePrompt): boolean | Promise<boolean>;
+  onCancel?(name: string, value: any, prompt: BasePrompt): boolean | Promise<boolean>;
+  stdin?: NodeJS.ReadStream;
+  stdout?: NodeJS.WriteStream;
+}
+
+interface Choice {
+  name: string;
+  message?: string;
+  value?: unknown;
+  hint?: string;
+  role?: string;
+  enabled?: boolean;
+  disabled?: boolean | string;
+}
+
+interface ArrayPromptOptions extends BasePromptOptions {
+  type: "autocomplete" | "editable" | "form" | "multiselect" | "select" | "survey" | "list" | "scale";
+  choices: (string | Choice)[];
+  maxChoices?: number;
+  multiple?: boolean;
+  initial?: number;
+  delay?: number;
+  separator?: boolean;
+  sort?: boolean;
+  linebreak?: boolean;
+  edgeLength?: number;
+  align?: "left" | "right";
+  scroll?: boolean;
+}
+
+interface BooleanPromptOptions extends BasePromptOptions {
+  type: "confirm";
+  initial?: boolean;
+}
+
+interface StringPromptOptions extends BasePromptOptions {
+  type: "input" | "invisible" | "list" | "password" | "text";
+  initial?: string;
+  multiline?: boolean;
+}
+
+interface NumberPromptOptions extends BasePromptOptions {
+  type: "numeral";
+  min?: number;
+  max?: number;
+  delay?: number;
+  float?: boolean;
+  round?: boolean;
+  major?: number;
+  minor?: number;
+  initial?: number;
+}
+
+interface SnippetPromptOptions extends BasePromptOptions {
+  type: "snippet";
+  newline?: string;
+  template?: string;
+}
+
+interface SortPromptOptions extends BasePromptOptions {
+  type: "sort";
+  hint?: string;
+  drag?: boolean;
+  numbered?: boolean;
+}
+
+type PromptOptions =
+  | BasePromptOptions
+  | ArrayPromptOptions
+  | BooleanPromptOptions
+  | StringPromptOptions
+  | NumberPromptOptions
+  | SnippetPromptOptions
+  | SortPromptOptions;
+
+declare class BasePrompt extends EventEmitter {
+  constructor(options?: PromptOptions);
+  render(): void;
+  run(): Promise<any>;
+}

package/actions/render-template.ts

@@ -0,0 +1,29 @@
+import type { Action, Context } from "../types.ts";
+
+export function renderTemplate({
+  templatePath,
+  template,
+  getData,
+  save,
+}: {
+  template: string;
+  templatePath: string;
+  getData?: (ctx: Context) => Record<string, unknown>;
+  save?: Action<{ templateContent?: string; destination?: string }>;
+}): Action {
+  if (!template) {
+    return () => undefined;
+  }
+
+  return function execute(params) {
+    const data = getData?.(params.context) ?? params.context;
+
+    const renderedTemplate = params.renderer.renderString({ template, data });
+
+    const renderedPath = params.renderer.renderString({ template: templatePath, data });
+
+    if (save) {
+      return save({ ...params, context: { ...params.context, templateContent: renderedTemplate, destination: renderedPath } });
+    }
+  };
+}

package/actions/run/run.ts

@@ -0,0 +1,20 @@
+import type { BaseIssue, BaseAction, Config, InferIssue, InferOutput } from "../../types/index.ts";
+
+/**
+ * Parses an unknown input based on a schema.
+ *
+ * @param action The action to be used.
+ * @param input The input to be parsed.
+ * @param config The run configuration.
+ *
+ * @returns The parsed input.
+ */
+export function run<const Action extends BaseAction<unknown, unknown>>(action: Action, input: unknown): InferOutput<Action> {
+  const context = action["~run"]({ value: input }, {});
+
+  if (context.issues) {
+    throw new Error("msg");
+  }
+
+  return context.value;
+}

package/actions/select-generator.ts

@@ -0,0 +1,24 @@
+import type { Action, Config } from "../types.ts";
+import { prompt } from "./prompt.ts";
+import { Renderer } from "../renderer.ts";
+import { runGenerator } from "../runner.ts";
+import assert from "node:assert";
+
+export function selectGenerator(config: Config): Action {
+  const choices = config.generators.map(({ name, description }) => ({
+    name,
+    hint: description,
+  }));
+
+  return () => [
+    prompt([{ type: "select", choices, message: "select", name: "generator" }]),
+
+    function runSelectedGenerator(params) {
+      const generator = config.generators.find((generator) => generator.name === params?.context?.answers?.generator);
+
+      assert(generator);
+
+      return runGenerator({ context: { errors: [], answers: {} }, renderer: new Renderer(), generator });
+    },
+  ];
+}

package/actions/use.ts

@@ -0,0 +1,9 @@
+import type { Action } from "../types.ts";
+
+// TODO: implement use in a way, that it can use actions from some repository... Maybe...
+
+export function use(): Action {
+  return function execute(_params) {
+    throw new Error("Action is not implemented");
+  };
+}

package/actions/validate-answers.ts

@@ -0,0 +1,13 @@
+import type { Action } from "../types.ts";
+
+import * as v from "valibot";
+
+const primitiveSchema = v.union([v.pipe(v.string(), v.minLength(1)), v.boolean()]);
+
+const defaultSchema = v.record(v.string(), v.union([primitiveSchema, v.array(primitiveSchema)]));
+
+export function validateAnswers<Schema extends v.BaseAction<unknown, unknown, v.BaseIssue<unknown>>>(schema?: Schema): Action {
+  return function execute(params) {
+    v.assert(schema ?? defaultSchema, params.context.answers);
+  };
+}

package/actions/write/write.ts

@@ -0,0 +1,69 @@
+import type { BaseIssue, BaseAction, ErrorMessage, Context, OutputContext, BaseContext } from "../../types/index.ts";
+// import { _addIssue, _getStandardProps } from "../../utils/index.ts";
+
+/**
+ * Write issue interface.
+ */
+export interface WriteIssue extends BaseIssue<unknown> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: "action";
+  /**
+   * The issue type.
+   */
+  readonly type: "string";
+}
+
+/**
+ * Write schema interface.
+ */
+export interface WriteAction<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 WriteActionConfig = {
+  destination?: string;
+  templateContent?: string;
+  mode?: "force" | "skip-if-exists";
+};
+
+// /**
+//  * Creates a string schema.
+//  *
+//  * @param config The error config.
+//  *
+//  * @returns A string schema.
+//  */
+
+export function write<Ctx extends Record<string, any>>(config?: WriteActionConfig): WriteAction<WriteActionConfig, Ctx>;
+export function write<Ctx extends undefined = undefined>(config: WriteActionConfig): WriteAction<WriteActionConfig, {}>;
+export function write<Ctx extends undefined | Record<string, any> = undefined>(
+  config?: WriteActionConfig,
+): WriteAction<WriteActionConfig, Ctx extends undefined ? {} : Ctx> {
+  return {
+    kind: "action",
+    expects: "string",
+
+    config: config ?? {},
+    "~run"(context, config) {
+      context.renderer;
+
+      if (typeof context.value === "string") {
+        // @ts-expect-error
+        context.typed = true;
+      } else {
+        // _addIssue(this, "type", context, config);
+      }
+      // @ts-expect-error
+      return context as OutputContext<string, WriteIssue>;
+    },
+  };
+}
+
+//  hooks?: ActionHooks;

package/actions/write.ts

@@ -0,0 +1,52 @@
+import { access, mkdir, rm, writeFile } from "node:fs/promises";
+
+import type { Action } from "../types.ts";
+import assert from "node:assert";
+import { dirname } from "node:path";
+
+export type WriteActionConfig = {
+  destination?: string;
+  templateContent?: string;
+  mode?: "force" | "skip-if-exists";
+};
+
+export function write({
+  destination: writeDestination,
+  templateContent: writeContent,
+  mode,
+}: WriteActionConfig): Action<{ templateContent?: string; destination?: string }> {
+  return async function execute({ context: { templateContent: executeContent, destination: executeDestination } }) {
+    const destination = executeDestination || writeDestination;
+    const templateContent = executeContent || writeContent;
+
+    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));
+  } satisfies Action<{ templateContent?: string; destination?: string }>;
+}
+
+function fileExists(destination: string) {
+  return access(destination).then(
+    () => true,
+    () => false,
+  );
+}

package/biome.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.2.5/schema.json",
+  "vcs": {
+    "enabled": false,
+    "clientKind": "git",
+    "useIgnoreFile": false
+  },
+  "files": {
+    "ignoreUnknown": false
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "lineWidth": 160
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double"
+    }
+  },
+  "assist": {
+    "enabled": true,
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  }
+}

package/bun.lock

@@ -0,0 +1,68 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "@codeandmoney/jargal",
+      "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",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.3.0", "", { "dependencies": { "bun-types": "1.3.0" } }, "sha512-+lAGCYjXjip2qY375xX/scJeVRmZ5cY0wyHYyCYxNcdEXrQ4AOe3gACgd4iQ8ksOslJtW4VNxBJ8llUwc3a6AA=="],
+
+    "@types/node": ["@types/node@24.7.2", "", { "dependencies": { "undici-types": "~7.14.0" } }, "sha512-/NbVmcGTP+lj5oa4yiYxxeBjRivKQ5Ns1eSZeB99ExsEQ6rX5XYU1Zy/gGxY/ilqtD4Etx9mKyrPxZRetiahhA=="],
+
+    "@types/react": ["@types/react@19.2.2", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-6mDvHUFSjyT2B2yeNx2nUgMxh9LtOWvkhIU3uePn2I2oyNymUAX1NIsdgviM4CH+JSrp2D2hsMvJOkxY+0wNRA=="],
+
+    "ansi-colors": ["ansi-colors@4.1.3", "", {}, "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw=="],
+
+    "ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "bun-types": ["bun-types@1.3.0", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-u8X0thhx+yJ0KmkxuEo9HAtdfgCBaM/aI9K90VQcQioAmkVp3SG3FkwWGibUFz3WdXAdcsqOcbU40lK7tbHdkQ=="],
+
+    "change-case": ["change-case@5.4.4", "", {}, "sha512-HRQyTk2/YPEkt9TnUPbOpr64Uw3KOicFWPVBb+xiHvd6eBx/qPr9xqfBFDT8P2vWsvvz4jbEkfDe71W3VyNu2w=="],
+
+    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
+
+    "enquirer": ["enquirer@2.4.1", "", { "dependencies": { "ansi-colors": "^4.1.1", "strip-ansi": "^6.0.1" } }, "sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ=="],
+
+    "es-toolkit": ["es-toolkit@1.40.0", "", {}, "sha512-8o6w0KFmU0CiIl0/Q/BCEOabF2IJaELM1T2PWj6e8KqzHv1gdx+7JtFnDwOx1kJH/isJ5NwlDG1nCr1HrRF94Q=="],
+
+    "handlebars": ["handlebars@4.7.8", "", { "dependencies": { "minimist": "^1.2.5", "neo-async": "^2.6.2", "source-map": "^0.6.1", "wordwrap": "^1.0.0" }, "optionalDependencies": { "uglify-js": "^3.1.4" }, "bin": { "handlebars": "bin/handlebars" } }, "sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ=="],
+
+    "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="],
+
+    "neo-async": ["neo-async@2.6.2", "", {}, "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw=="],
+
+    "source-map": ["source-map@0.6.1", "", {}, "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="],
+
+    "strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "title-case": ["title-case@4.3.2", "", {}, "sha512-I/nkcBo73mO42Idfv08jhInV61IMb61OdIFxk+B4Gu1oBjWBPOLmhZdsli+oJCVaD+86pYQA93cJfFt224ZFAA=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "uglify-js": ["uglify-js@3.19.3", "", { "bin": { "uglifyjs": "bin/uglifyjs" } }, "sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ=="],
+
+    "undici-types": ["undici-types@7.14.0", "", {}, "sha512-QQiYxHuyZ9gQUIrmPo3IA+hUl4KYk8uSA7cHrcKd/l3p1OTpZcM0Tbp9x7FAtXdAYhlasd60ncPpgu6ihG6TOA=="],
+
+    "valibot": ["valibot@1.1.0", "", { "peerDependencies": { "typescript": ">=5" }, "optionalPeers": ["typescript"] }, "sha512-Nk8lX30Qhu+9txPYTwM0cFlWLdPFsFr6LblzqIySfbZph9+BFsAHsNvHOymEviUepeIW6KFHzpX8TKhbptBXXw=="],
+
+    "wordwrap": ["wordwrap@1.0.0", "", {}, "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q=="],
+
+    "bun-types/@types/node": ["@types/node@24.7.0", "", { "dependencies": { "undici-types": "~7.14.0" } }, "sha512-IbKooQVqUBrlzWTi79E8Fw78l8k1RNtlDDNWsFZs7XonuQSJ8oNYfEeclhprUldXISRMLzBpILuKgPlIxm+/Yw=="],
+  }
+}

package/exports.ts

@@ -0,0 +1,8 @@
+// Run
+export { run } from "./runner.ts";
+
+// Helpers
+export { textHelpers } from "./lib.ts";
+
+// Renderer
+export { Renderer } from "./renderer.ts";

package/jargal.ts

@@ -0,0 +1,156 @@
+import { merge, toMerged } from "es-toolkit";
+import { Renderer } from "./renderer";
+import { write } from "./actions/jargal-write";
+import { resolve, dirname, join } from "path";
+import { mkdir } from "fs/promises";
+import { writeFile } from "fs/promises";
+
+import { templates, type TemplatesMap } from "./actions/jargal-templates";
+import { context } from "./actions/jargal-context";
+
+export { templates, context };
+
+export type RenderEntry = { control: "user"; data: any; pathTemplate: string; contentTemplate: string } | { control?: "auto"; data: any; destination: string };
+
+export class Jargal<const in out Context> {
+  #context = {
+    templates: { default: {} },
+    renderData: [] as { baseSavePath: string; data: any }[],
+    renderedContent: [] as { savePath: string; content: string }[],
+  } as Context;
+
+  #renderer: Renderer;
+
+  get context() {
+    return this.#context;
+  }
+
+  constructor() {
+    this.#renderer = new Renderer();
+  }
+
+  setContext<Setter extends (...args: any) => any>(setter: Setter): Jargal<ReturnType<Setter> & Context>;
+  setContext<Setter extends Record<string, any>>(setter: Setter): Jargal<Setter & Context>;
+  setContext(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(params?: {
+    composeRenderData?: (ctx: Context) => RenderEntry[] | Promise<RenderEntry[]>;
+    scope?: Context extends { templates: { [key: string]: any } } ? keyof Context["templates"] : "default";
+  }): Promise<Jargal<Context & { renderedContent: { savePath: string; content: string }[] }>> {
+    const composeData: (ctx: Context) => RenderEntry[] | Promise<RenderEntry[]> =
+      params?.composeRenderData ??
+      // @ts-expect-error
+      ((ctx: Context) => ctx.renderData);
+
+    // @ts-expect-error
+    const templatesToRender = this.#context.templates[params?.scope ?? "default"] as TemplatesMap;
+
+    // console.log({ templatesToRender})
+
+    const composedData = await composeData(this.#context);
+
+    // console.log({ composedData})
+
+    for (const renderEntry of composedData) {
+      if (!renderEntry.control || renderEntry.control === "auto") {
+        for (const [filename, template] of Object.entries(templatesToRender)) {
+          // @ts-expect-error
+          this.#context.renderedContent.push({
+            savePath: this.#renderer.renderString({ template: join(renderEntry.destination, template.savePath), data: renderEntry.data }),
+            content: this.#renderer.renderString({ template: template.templateContent, data: renderEntry.data }),
+          });
+        }
+
+        continue;
+      }
+
+      if (renderEntry.control === "user") {
+        // @ts-expect-error
+        this.#context.renderedContent.push({
+          savePath: this.#renderer.renderString({ template: renderEntry.pathTemplate, data: renderEntry.data }),
+          content: this.#renderer.renderString({ template: renderEntry.contentTemplate, data: renderEntry.data }),
+        });
+
+        continue;
+      }
+    }
+
+    //     const entryContentTemplate = renderEntry.contentTemplate;
+
+    // let renderedContent: string | undefined = undefined;
+    // let renderedPath: string | undefined = undefined;
+
+    // if (renderEntry.contentTemplate) {
+    //   const templateToRender =
+    //     // @ts-expect-error
+    //     (this.#context.templates[params?.scope ?? "default"] as TemplatesMap)[renderEntry.contentTemplate]?.templateContent || renderEntry.contentTemplate;
+
+    //   renderedContent = this.#renderer.renderString({ template: templateToRender, data: renderEntry.data });
+    //   continue;
+    // }
+
+    // if (renderEntry.pathTemplate) {
+    //   renderedPath = this.#renderer.renderString({ template: renderEntry.pathTemplate, data: renderEntry.data });
+    //   continue;
+    // }
+
+    // for (const [filename, template] of Object.entries(templatesToRender)) {
+    //   // console.log({ renderEntry, template });
+
+    //   // @ts-expect-error
+    //   this.#context.renderedContent.push({
+    //     savePath:
+    //       renderedPath ||
+    //       this.#renderer.renderString({
+    //         template: renderEntry.baseSavePath ?? (renderEntry?.fullSavePath ? renderEntry?.fullSavePath : join(renderEntry.baseSavePath, template.savePath)),
+    //         data: renderEntry.data,
+    //       }),
+    //     content:
+    //       renderedContent || this.#renderer.renderString({ template: renderEntry?.contentTemplate ?? template.templateContent, data: renderEntry.data }),
+    //   });
+    // }
+
+    return this as any;
+  }
+
+  async write(
+    write?: (params: {
+      savePath: string;
+      content: string;
+      defultWrite: (params: { savePath: string; content: string }) => Promise<void>;
+    }) => void | Promise<void>,
+  ): Promise<void> {
+    if (typeof write === "function") {
+      // @ts-expect-error
+      for (const renderConfig of this.#context.renderedContent as { savePath: string; content: string }[]) {
+        await write({ ...renderConfig, defultWrite });
+      }
+
+      return;
+    }
+
+    // console.log({ renderedContent: this.#context.renderedContent})
+    // @ts-expect-error
+    for (const renderConfig of this.#context.renderedContent as { savePath: string; content: string }[]) {
+      defultWrite(renderConfig);
+    }
+  }
+}
+
+async function defultWrite({ savePath, content }: { savePath: string; content: string }): Promise<void> {
+  try {
+    await mkdir(dirname(savePath), { recursive: true });
+  } catch (error) {
+    console.error({ savePath, content, error });
+  }
+  await writeFile(savePath, new TextEncoder().encode(content), {});
+}