@codeandmoney/jargal 0.0.0-rc.2 → 0.0.0-rc.5

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

@@ -1,10 +1,10 @@
 import { merge } from "es-toolkit";
 import { readonly } from "../lib.ts";
-import type { Action, Context, ContextAction, DeepReadonly } from "../types.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.context));
+    const newContext = await callback(readonly(params));
     merge(params.context, newContext);
   };
 }

package/actions/echo.ts

@@ -1,7 +1,19 @@
-import type { Action } from "../types.ts";
+import type { Action, ActionParams } from "../types.ts";
 
-export function echo(message?: string): Action {
-  return function execute() {
-    console.log(message ?? "Hello, World!");
+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/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,64 @@
+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";
+
+  let record = { [scopeKey]: {} } as Record<string, TemplatesMap>;
+
+  const resolvedPath = resolve(params.path);
+
+  for await (const templatePath of walkDir(resolvedPath)) {
+    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) {
+      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_);
+      }
+
+      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

@@ -1,24 +1,94 @@
 import type { ContextAction } from "../types.ts";
 import { readdir, readFile } from "node:fs/promises";
-import path from "node:path";
+import path, { resolve } from "node:path";
 
-export function loadTemplates(templatesPath: string, scope?: string): ContextAction {
+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 Record<string, Map<string, { fullPath: string; realativePath: string; content: string }>>;
+    const record = { ...params.context.templates } as any as Record<string, Map<string, TemplateData>>;
 
-    if (scope) {
-      Object.assign(record, { [scope]: new Map() });
+    if (options.scope) {
+      Object.assign(record, { [options.scope]: new Map() });
     }
 
-    for await (const fullPath of walkDir(templatesPath)) {
-      const realativePath = path.relative(templatesPath, fullPath);
+    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;
+      }
 
-      const contentRaw = await readFile(path.resolve(templatesPath, fullPath));
+      if (options.hooks?.onDataReady?.length) {
+        let path_ = realativePath;
+        let data_ = data;
 
-      record[scope ? scope : "templates"]?.set(realativePath, { content: new TextDecoder().decode(contentRaw), fullPath, realativePath });
+        for (const hook of options.hooks.onDataReady) {
+          [path_, data_] = hook(path_, data_);
+        }
+
+        record[options.scope ? options.scope : "templates"]?.set(path_, data_);
+      }
     }
 
-    return record;
+    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 };
   };
 }
 
@@ -26,12 +96,12 @@ async function* walkDir(dir: string): AsyncGenerator<string, void, void> {
   const entries = await readdir(dir, { withFileTypes: true });
 
   for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
+    const templatePath = path.join(dir, entry.name);
 
     if (entry.isDirectory()) {
-      yield* walkDir(fullPath);
+      yield* walkDir(templatePath);
     } else if (entry.isFile()) {
-      yield fullPath;
+      yield templatePath;
     }
   }
 }

package/actions/parallel.ts

@@ -1,7 +1,7 @@
 import { executeAction } from "../runner.ts";
 import type { Action } from "../types.ts";
 
-export function parallel(...actions: Action[]): Action {
+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 })));
   };