@codeandmoney/jargal 0.0.0-dev.11 → 0.0.0-dev.13

package/actions/combine.ts

@@ -4,7 +4,11 @@ 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 });
+      await executeAction({
+        action,
+        context: params.context,
+        renderer: params.renderer,
+      });
     }
   };
 }

package/actions/jargal-templates.ts

@@ -2,7 +2,12 @@ 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 TemplateData = {
+  templatePath: string;
+  savePath: string;
+  templateContent: string;
+  metadata?: Record<string, any>;
+};
 
 export type TemplatesMap = Record<string, TemplateData>;
 
@@ -12,7 +17,9 @@ export async function templates<Scope extends string | undefined = undefined>(pa
   path: string;
   scope?: Scope;
   engine?: "handlebars";
-  hooks?: { onDataReady?: ((path: string, data: TemplateData) => [path: string, data: TemplateData])[] };
+  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" : "";
@@ -30,7 +37,11 @@ export async function templates<Scope extends string | undefined = undefined>(pa
     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 };
+    const data: TemplateData = {
+      templateContent: new TextDecoder().decode(contentRaw),
+      templatePath,
+      savePath,
+    };
 
     if (!params.hooks) {
       assert(record[scopeKey]);

package/actions/load-templates.ts

@@ -2,13 +2,19 @@ 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 };
+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])[] };
+    hooks?: {
+      onDataReady?: ((path: string, data: TemplateData) => [path: string, data: TemplateData])[];
+    };
   },
 ): ContextAction<{ templates: Record<string, Map<string, TemplateData>> }> {
   return async function execute(params) {
@@ -22,7 +28,11 @@ export function loadTemplates(
       const realativePath = path.relative(templatesPath, templatePath);
 
       const contentRaw = await readFile(path.resolve(templatesPath, templatePath));
-      const data: TemplateData = { templateContent: new TextDecoder().decode(contentRaw), templatePath, realativePath };
+      const data: TemplateData = {
+        templateContent: new TextDecoder().decode(contentRaw),
+        templatePath,
+        realativePath,
+      };
 
       if (!options.hooks) {
         record[options.scope ? options.scope : "templates"]?.set(realativePath, data);
@@ -48,7 +58,9 @@ export function loadTemplates(
 export async function templates<Scope extends string | undefined = undefined>(params: {
   path: string;
   scope?: Scope;
-  hooks?: { onDataReady?: ((path: string, data: TemplateData) => [path: string, data: TemplateData])[] };
+  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>>;
@@ -68,7 +80,11 @@ export async function templates<Scope extends string | undefined = undefined>(pa
     const realativePath = path.relative(resolvedPath, templatePath);
 
     const contentRaw = await readFile(path.resolve(resolvedPath, templatePath));
-    const data: TemplateData = { templateContent: new TextDecoder().decode(contentRaw), templatePath, realativePath };
+    const data: TemplateData = {
+      templateContent: new TextDecoder().decode(contentRaw),
+      templatePath,
+      realativePath,
+    };
 
     if (!params.hooks) {
       record[params.scope ? params.scope : "default"]?.set(realativePath, data);
@@ -87,7 +103,9 @@ export async function templates<Scope extends string | undefined = undefined>(pa
     }
   }
 
-  return function setter(_ctx: Record<string, any>): { templates: Record<string, Map<string, TemplateData>> } {
+  return function setter(_ctx: Record<string, any>): {
+    templates: Record<string, Map<string, TemplateData>>;
+  } {
     return { templates: record };
   };
 }

package/actions/parallel.ts

@@ -3,6 +3,14 @@ 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 })));
+    await Promise.all(
+      actions.map((action) =>
+        executeAction({
+          action,
+          context: params.context,
+          renderer: params.renderer,
+        }),
+      ),
+    );
   };
 }

package/actions/render-template.ts

@@ -20,10 +20,20 @@ export function renderTemplate({
 
     const renderedTemplate = params.renderer.renderString({ template, data });
 
-    const renderedPath = params.renderer.renderString({ template: templatePath, data });
+    const renderedPath = params.renderer.renderString({
+      template: templatePath,
+      data,
+    });
 
     if (save) {
-      return save({ ...params, context: { ...params.context, templateContent: renderedTemplate, destination: renderedPath } });
+      return save({
+        ...params,
+        context: {
+          ...params.context,
+          templateContent: renderedTemplate,
+          destination: renderedPath,
+        },
+      });
     }
   };
 }

package/actions/select-generator.ts

@@ -18,7 +18,11 @@ export function selectGenerator(config: Config): Action {
 
       assert(generator);
 
-      return runGenerator({ context: { errors: [], answers: {} }, renderer: new Renderer(), generator });
+      return runGenerator({
+        context: { errors: [], answers: {} },
+        renderer: new Renderer(),
+        generator,
+      });
     },
   ];
 }

package/actions/write.ts

@@ -10,11 +10,10 @@ export type WriteActionConfig = {
   mode?: "force" | "skip-if-exists";
 };
 
-export function write({
-  destination: writeDestination,
-  templateContent: writeContent,
-  mode,
-}: WriteActionConfig): Action<{ templateContent?: string; destination?: string }> {
+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;

package/jargal.ts

@@ -10,7 +10,14 @@ 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 type RenderEntry =
+  | {
+      control: "user";
+      data: any;
+      pathTemplate: string;
+      contentTemplate: string;
+    }
+  | { control?: "auto"; data: any; destination: string };
 
 export class Jargal<const in out Context> {
   #context = {
@@ -65,8 +72,14 @@ export class Jargal<const in out Context> {
         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 }),
+            savePath: this.#renderer.renderString({
+              template: join(renderEntry.destination, template.savePath),
+              data: renderEntry.data,
+            }),
+            content: this.#renderer.renderString({
+              template: template.templateContent,
+              data: renderEntry.data,
+            }),
           });
         }
 
@@ -76,8 +89,14 @@ export class Jargal<const in out Context> {
       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 }),
+          savePath: this.#renderer.renderString({
+            template: renderEntry.pathTemplate,
+            data: renderEntry.data,
+          }),
+          content: this.#renderer.renderString({
+            template: renderEntry.contentTemplate,
+            data: renderEntry.data,
+          }),
         });
 
         continue;
@@ -131,7 +150,10 @@ export class Jargal<const in out Context> {
   ): Promise<void> {
     if (typeof write === "function") {
       // @ts-expect-error
-      for (const renderConfig of this.#context.renderedContent as { savePath: string; content: string }[]) {
+      for (const renderConfig of this.#context.renderedContent as {
+        savePath: string;
+        content: string;
+      }[]) {
         await write({ ...renderConfig, defultWrite });
       }
 
@@ -140,8 +162,11 @@ export class Jargal<const in out Context> {
 
     // console.log({ renderedContent: this.#context.renderedContent})
     // @ts-expect-error
-    for (const renderConfig of this.#context.renderedContent as { savePath: string; content: string }[]) {
-      defultWrite(renderConfig);
+    for (const renderConfig of this.#context.renderedContent as {
+      savePath: string;
+      content: string;
+    }[]) {
+      await defultWrite(renderConfig);
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeandmoney/jargal",
-  "version": "0.0.0-dev.11",
+  "version": "0.0.0-dev.13",
   "description": "Renderer",
   "license": "MIT",
   "author": "Code & Money Team",