@codeandmoney/jargal 0.0.2-RC.5 → 0.0.2-RC.6

package/actions/exports.ts

@@ -3,6 +3,6 @@ export { prompt } from "./prompt.ts"
 export { parallel } from "./parallel.ts"
 export { write } from "./write.ts"
 export { echo } from "./echo.ts"
-export { validateAnswers } from "./validate_answers.ts"
-export { loadTemplates } from "./load_templates.ts"
-export { renderTemplate } from "./render_template.ts"
+export { validateAnswers } from "./validate-answers.ts"
+export { loadTemplates } from "./load-templates.ts"
+export { renderTemplate } from "./render-template.ts"

package/actions/{load_templates.ts → load-templates.ts}

@@ -1,5 +1,5 @@
 import type { ContextAction } from "../types.ts"
-import { promises as fs } from "node:fs"
+import { readdir, readFile } from "node:fs/promises"
 import path from "node:path"
 
 export function loadTemplates( templatesPath: string ): ContextAction {
@@ -9,7 +9,7 @@ export function loadTemplates( templatesPath: string ): ContextAction {
     for await ( const fullPath of walkDir( templatesPath ) ) {
       const realativePath = path.relative( templatesPath, fullPath )
 
-      const contentRaw = await fs.readFile( path.resolve( templatesPath, fullPath ) )
+      const contentRaw = await readFile( path.resolve( templatesPath, fullPath ) )
 
       templates.set( realativePath, { content: new TextDecoder().decode( contentRaw ), fullPath, realativePath } )
     }
@@ -19,7 +19,7 @@ export function loadTemplates( templatesPath: string ): ContextAction {
 }
 
 async function* walkDir( dir: string ): AsyncGenerator<string, void, void> {
-  const entries = await fs.readdir( dir, { withFileTypes: true } )
+  const entries = await readdir( dir, { withFileTypes: true } )
 
   for ( const entry of entries ) {
     const fullPath = path.join( dir, entry.name )

package/actions/{render_template.ts → render-template.ts}

@@ -1,12 +1,15 @@
 import type { Action, Context } from "../types.ts"
-import type { WriteActionConfig } from "./write.ts"
 
 export function renderTemplate( { fullpath, template, getData, write }: {
   template: string
   fullpath: string
   getData?: ( ctx: Context ) => Record<string, unknown>
-  write?: ( config: WriteActionConfig ) => Action
+  write?: Action<{ content?: string; destination?: string }>
 } ): Action {
+  if ( !template ) {
+    return () => undefined
+  }
+
   return function execute( params ) {
     const data = getData?.( params.context ) ?? params.context
 
@@ -15,7 +18,7 @@ export function renderTemplate( { fullpath, template, getData, write }: {
     const renderedPath = params.renderer.renderString( { template: fullpath, data } )
 
     if ( write ) {
-      return write( { content: renderedTemplate, destination: renderedPath } )
+      return write( { ...params, content: renderedTemplate, destination: renderedPath } )
     }
   }
 }

package/actions/{select_generator.ts → select-generator.ts}

@@ -1,8 +1,8 @@
-import { assert } from "@std/assert"
 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 } ) )

package/actions/write.ts

@@ -1,12 +1,11 @@
 // TODO: get rid of `node:` imports and "del", "mkdirp" libraries
 import { access, mkdir, rm, writeFile } from "node:fs/promises"
 
-import { dirname } from "@std/path"
-
 import type { Action } from "../types.ts"
+import assert from "node:assert"
+import { dirname } from "node:path"
 
 // type WriteActionConfig = {
-
 //   data?: Record<string, unknown>
 //   destination: string
 //   writeMode?: "skip-if-exists" | "force"
@@ -16,34 +15,38 @@ import type { Action } from "../types.ts"
 //   |
 // )
 
-export type WriteActionConfig = {
-  content: string
-  destination: string
-  mode?: "force" | "skip-if-exists"
-}
+export type WriteActionConfig = { destination?: string; content?: string; mode?: "force" | "skip-if-exists" }
+
+export function write(
+  { destination, content, mode }: WriteActionConfig,
+): Action<{ content?: string; destination?: string }> {
+  return async function execute( { content: content_, destination: destination_ } ) {
+    const dest = destination || destination_
+    const cntn = content || content_
+
+    assert( dest, "must provide `dest`" )
+    assert( cntn, "must provide `cntn`" )
 
-export function write( config: WriteActionConfig ): Action {
-  return async function execute() {
-    await mkdir( dirname( config.destination ), { recursive: true } )
+    await mkdir( dirname( dest ), { recursive: true } )
 
-    let doesExist = await fileExists( config.destination )
+    let doesExist = await fileExists( dest )
 
-    if ( doesExist && config.mode === "force" ) {
-      await rm( config.destination, { recursive: true } )
+    if ( doesExist && mode === "force" ) {
+      await rm( dest, { recursive: true } )
       doesExist = false
     }
 
-    if ( doesExist && config.mode !== "skip-if-exists" ) {
-      throw `File already exists\n -> ${config.destination}`
+    if ( doesExist && mode !== "skip-if-exists" ) {
+      throw `File already exists\n -> ${dest}`
     }
 
-    if ( doesExist && config.mode === "skip-if-exists" ) {
-      console.info( `[SKIPPED] ${config.destination} (exists)` )
+    if ( doesExist && mode === "skip-if-exists" ) {
+      console.info( `[SKIPPED] ${dest} (exists)` )
       return
     }
 
-    await writeFile( config.destination, new TextEncoder().encode( config.content ) )
-  }
+    await writeFile( dest, new TextEncoder().encode( cntn ) )
+  } satisfies Action<{ content?: string; destination?: string }>
 
   // if(eager) {
   //   return execute()

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeandmoney/jargal",
-  "version": "0.0.2-RC.5",
+  "version": "0.0.2-RC.6",
   "description": "Renderer",
   "license": "MIT",
   "author": "Code & Money Team",

package/package.json

@@ -1,36 +1,36 @@
 {
   "name": "@codeandmoney/jargal",
-  "version": "0.0.2-RC.5",
+  "version": "0.0.2-RC.6",
   "private": false,
   "publishConfig": {
-  "access": "public"
-},
-"description": "Renderer",
-"license": "MIT",
-"author": "Code & Money Team",
-"exports": {
-  ".": "./mod.ts",
-  "./types": "./types.ts",
-  "./actions": "./actions/exports.ts"
-},
-"fmt": {
-  "semiColons": false,
-  "trailingCommas": "onlyMultiLine",
-  "quoteProps": "asNeeded",
-  "indentWidth": 2,
-  "lineWidth": 120,
-  "spaceAround": true
-},
-"devDependencies": {
-  "@types/node": "^24.7.0",
-  "bun-types": "^1.2.23"
-},
-"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"
-}
+    "access": "public"
+  },
+  "description": "Renderer",
+  "license": "MIT",
+  "author": "Code & Money Team",
+  "exports": {
+    ".": "./mod.ts",
+    "./types": "./types.ts",
+    "./actions": "./actions/exports.ts"
+  },
+  "fmt": {
+    "semiColons": false,
+    "trailingCommas": "onlyMultiLine",
+    "quoteProps": "asNeeded",
+    "indentWidth": 2,
+    "lineWidth": 120,
+    "spaceAround": true
+  },
+  "devDependencies": {
+    "@types/node": "^24.7.0",
+    "bun-types": "^1.2.23"
+  },
+  "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"
+  }
 }

package/{runner_test.ts → runner.test.ts}

@@ -1,13 +1,16 @@
+import test from "node:test"
+import assert from "node:assert"
+import { join } from "node:path"
+
 import { run } from "./runner.ts"
-import { assert } from "@std/assert"
-import { join } from "@std/path"
 import { blank1, blank2 } from "./actions/blank.ts"
 
 import type { Config, GeneratorConfig } from "./types.ts"
-import { loadTemplates } from "./actions/load_templates.ts"
+
 import { context } from "./actions/context.ts"
+import { loadTemplates } from "./actions/load-templates.ts"
 
-Deno.test("simple", async () => {
+test("simple", async () => {
   const simple: GeneratorConfig = {
     name: "simple",
     description: "description",
@@ -16,7 +19,7 @@ Deno.test("simple", async () => {
       blank2,
       context( () => ( { kek: Math.random() } ) ),
       console.log,
-      loadTemplates( join( Deno.cwd(), "actions" ) ),
+      loadTemplates( join( process.cwd(), "actions" ) ),
     ],
   }
 

package/runner.ts

@@ -1,9 +1,8 @@
-import { assert } from "@std/assert"
 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 { selectGenerator } from "./actions/select-generator.ts"
+import assert from "node:assert"
 
 export async function runGenerator( { context, generator, renderer }: GeneratorParams ): Promise<void> {
   assert( generator )
@@ -19,10 +18,18 @@ export async function executeAction(
 ): Promise<void | Action | Action[]> {
   if ( Array.isArray( action ) ) {
     for ( const action_ of action ) {
-      return await executeAction( { action: action_, context, renderer } )
+      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 ) {
@@ -37,7 +44,7 @@ async function execRecursive(
   { context, renderer }: Omit<ExecuteActionParams, "action">,
 ): Promise<Action | Action[] | void> {
   if ( Array.isArray( executed ) ) {
-    const executionResults: (Action)[] = []
+    const executionResults: Action[] = []
 
     for ( const action of executed ) {
       const result = await executeAction( { action, context, renderer } )
@@ -92,9 +99,7 @@ export async function run( config_: Config ): Promise<void> {
     renderer: new Renderer(),
     generator: {
       name: "select",
-      actions: [
-        selectGenerator( config ),
-      ],
+      actions: [ selectGenerator( config ) ],
     },
   } )
 }

package/types.ts

@@ -48,7 +48,9 @@ export type HelperFn = ( str: string ) => string
 
 export interface TextHelpers extends Record<string, HelperFn> {}
 
-export type Action = ( params: ActionParams ) => void | Action | Action[] | Promise<void | Action | Action[]>
+export type Action<T extends object = {}> = (
+  params: ActionParams & T,
+) => void | Action | Action[] | Promise<void | Action | Action[]>
 
 export interface ActionHooksFailures {
   path: string