@nci-gis/js-tmpl 0.0.1-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 nci-gis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,348 @@
+# js-tmpl
+
+> A lightweight, deterministic file templating engine built on Handlebars
+
+[![npm version](https://img.shields.io/npm/v/@nci-gis/js-tmpl.svg)](https://www.npmjs.com/package/@nci-gis/js-tmpl)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## What is js-tmpl?
+
+js-tmpl is a **pure transformation layer** that generates files and directory structures from templates with predictable, explicit behavior.
+
+It's designed for:
+
+- DevOps configuration management
+- Code scaffolding and generation
+- Multi-environment deployments
+- Project template systems
+
+**Not a framework. Not a workflow tool. Just a focused rendering engine.**
+
+## Why js-tmpl?
+
+Most template tools are either too simple (basic string replacement) or too complex (opinionated frameworks). js-tmpl fills the gap:
+
+- ✅ **Engine-First**: Programmatic API, CLI is secondary
+- ✅ **Deterministic**: Same input → same output, always
+- ✅ **Explicit**: No magic defaults or hidden conventions
+- ✅ **Composable**: Small, focused layers
+- ✅ **Embeddable**: Designed to integrate into larger tools
+
+See [docs/00-Motivation.md](docs/00-Motivation.md) for the full story.
+
+## Features
+
+- 🎯 **Dynamic File Paths** - Use `${var}` placeholders in paths and filenames
+- 🧩 **Handlebars Templates** - Full Handlebars feature set (loops, conditionals, helpers)
+- 📦 **Partial System** - Reusable components with root and namespaced partials
+- ⚙️ **Flexible Configuration** - CLI args > project config > defaults
+- 🌲 **BFS Tree Walking** - Async, non-blocking template discovery
+- 🔒 **No Global State** - Isolated render passes, no pollution
+- 📝 **YAML/JSON Support** - Load values from either format
+
+## Installation
+
+```bash
+npm install @nci-gis/js-tmpl
+```
+
+**Requirements:** Node.js ≥ 20
+
+## Quick Start
+
+### 1. Create a values file
+
+```yaml
+# values.yaml
+project:
+  name: my-app
+  version: 1.0.0
+
+config:
+  port: 3000
+  host: localhost
+```
+
+### 2. Create templates
+
+```text
+templates/
+├── ${project.name}/
+│   └── config.json.hbs
+└── README.md.hbs
+```
+
+**Template content** (`templates/${project.name}/config.json.hbs`):
+
+```handlebars
+{
+  "name": "{{project.name}}",
+  "version": "{{project.version}}",
+  "server": {
+    "port": {{config.port}},
+    "host": "{{config.host}}"
+  }
+}
+```
+
+### 3. Render templates
+
+**CLI:**
+
+```bash
+js-tmpl render --values values.yaml
+```
+
+**Programmatic API:**
+
+```javascript
+import { resolveConfig, renderDirectory } from '@nci-gis/js-tmpl';
+
+const config = resolveConfig({
+  valuesFile: './values.yaml',
+  templateDir: './templates',
+  outDir: './dist'
+});
+
+await renderDirectory(config);
+```
+
+### 4. Get output
+
+```text
+dist/
+├── my-app/
+│   └── config.json
+└── README.md
+```
+
+## Core Concepts
+
+### Configuration Precedence
+
+```text
+CLI arguments
+  > Project config file (js-tmpl.config.yaml)
+    > Internal defaults
+```
+
+### View Model
+
+Templates receive a view object:
+
+```javascript
+{
+  ...valuesFromFile,  // Your YAML/JSON data
+  env: process.env    // Environment variables
+}
+```
+
+Access in templates:
+
+```handlebars
+{{project.name}}
+{{env.NODE_ENV}}
+```
+
+### Path Rendering
+
+Use `${var}` in file/folder paths:
+
+```text
+templates/
+└── ${env.NODE_ENV}/
+    └── config-${project.name}.yaml.hbs
+
+→ dist/production/config-my-app.yaml
+```
+
+### Partial System
+
+**Root partials** (`_name.hbs`):
+
+```text
+templates.partials/
+└── _header.hbs  → {{> header}}
+```
+
+**Namespaced partials** (`@group/name.hbs`):
+
+```text
+templates.partials/
+└── @common/
+    └── metadata.hbs  → {{> common.metadata}}
+```
+
+## CLI Reference
+
+```bash
+js-tmpl render [options]
+```
+
+### Options
+
+| Option                   | Description             | Default              |
+| ------------------------ | ----------------------- | -------------------- |
+| `-c, --values FILE`      | Values file (YAML/JSON) | **Required**         |
+| `-t, --template-dir DIR` | Template directory      | `templates`          |
+| `-o, --out DIR`          | Output directory        | `dist`               |
+| `-p, --partials-dir DIR` | Partials directory      | `templates.partials` |
+| `-x, --ext EXT`          | Template extension      | `.hbs`               |
+| `--config-file FILE`     | Explicit config file    | Auto-discovered      |
+
+### Examples of Usage
+
+```bash
+# Basic usage
+js-tmpl render --values data.yaml
+
+# Custom directories
+js-tmpl render \
+  --values data.yaml \
+  --template-dir ./my-templates \
+  --out ./output
+
+# Multi-environment
+NODE_ENV=production js-tmpl render --values prod-values.yaml
+```
+
+## Programmatic API
+
+See [docs/API.md](docs/API.md) for comprehensive API documentation.
+
+### Import
+
+```javascript
+import { resolveConfig, renderDirectory } from '@nci-gis/js-tmpl';
+```
+
+### resolveConfig(options)
+
+Resolves configuration with proper precedence.
+
+**Parameters:**
+
+- `options.valuesFile` (string, required) - Path to values file
+- `options.templateDir` (string) - Template directory path
+- `options.partialsDir` (string) - Partials directory path
+- `options.outDir` (string) - Output directory path
+- `options.extname` (string) - Template file extension
+- `options.configFile` (string) - Explicit config file path
+
+**Returns:** Resolved configuration object
+
+### renderDirectory(config)
+
+Executes the rendering process.
+
+**Parameters:**
+
+- `config` (object) - Configuration from `resolveConfig`
+
+**Returns:** Promise that resolves when rendering completes
+
+### Example
+
+```javascript
+import { resolveConfig, renderDirectory } from '@nci-gis/js-tmpl';
+
+const config = resolveConfig({
+  valuesFile: './values.yaml',
+  templateDir: './templates',
+  partialsDir: './partials',
+  outDir: './dist'
+});
+
+await renderDirectory(config);
+console.log('✅ Rendering complete');
+```
+
+## Project Configuration
+
+Create `js-tmpl.config.yaml` in your project root:
+
+```yaml
+templateDir: templates
+partialsDir: templates.partials
+outDir: dist
+extname: .hbs
+```
+
+Auto-discovered config files (in order):
+
+1. `js-tmpl.config.yaml`
+2. `js-tmpl.config.yml`
+3. `js-tmpl.config.json`
+4. `config/js-tmpl.yaml`
+5. `config/js-tmpl.json`
+
+## Examples
+
+See [examples/yaml-templates/](examples/yaml-templates/) for a complete working example demonstrating:
+
+- Dynamic file paths with `${env.NODE_ENV}`
+- Handlebars features (loops, conditionals)
+- Root and namespaced partials
+- Multi-format output (YAML, Markdown)
+
+## Testing
+
+This project has comprehensive test coverage:
+
+- 156 tests
+- 99.8% line coverage
+- 99.7% branch coverage
+
+See [tests/README.md](tests/README.md) for testing documentation.
+
+## Development Principles
+
+js-tmpl follows strict design principles:
+
+1. **Engine First, CLI Second** - Programmatic API is primary
+2. **Explicit Over Implicit** - No magic or hidden conventions
+3. **Deterministic Over Clever** - Predictable behavior
+4. **Separation of Concerns** - Each layer has one responsibility
+5. **Composable Over Monolithic** - Small, focused functions
+6. **Simple Over Feature-Rich** - Minimal API surface
+
+See [docs/PRINCIPLES.md](docs/PRINCIPLES.md) for details.
+
+## Roadmap
+
+See [ROADMAP.md](ROADMAP.md) for planned features and improvements.
+
+See [CHANGELOG.md](CHANGELOG.md) for version history.
+
+## Contributing
+
+We welcome contributions! Please read [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+For maintainers: See [CONTRIBUTING.md#release-process](CONTRIBUTING.md#release-process) for release instructions.
+
+## Installing Pre-release Versions
+
+```bash
+# Stable (latest)
+npm install @nci-gis/js-tmpl
+
+# Beta
+npm install @nci-gis/js-tmpl@beta
+
+# Alpha
+npm install @nci-gis/js-tmpl@alpha
+```
+
+## Security
+
+For security concerns, see [SECURITY.md](SECURITY.md).
+
+## License
+
+MIT © pasxd245
+
+## Links
+
+- [Documentation](docs/)
+- [Examples](examples/)
+- [Issue Tracker](https://github.com/nci-gis/js-tmpl/issues)
+- [NPM Package](https://www.npmjs.com/package/@nci-gis/js-tmpl)

package/bin/js-tmpl

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# CLI entry point for js-tmpl
+node "$(dirname "$0")/../src/cli/main.js" "$@"

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@nci-gis/js-tmpl",
+  "version": "0.0.1-beta.1",
+  "description": "The pure JavaScript templating engine that uses handlebars.",
+  "type": "module",
+  "bin": {
+    "js-tmpl": "bin/js-tmpl"
+  },
+  "exports": {
+    ".": {
+      "import": "./src/index.js"
+    }
+  },
+  "keywords": [
+    "js",
+    "templating",
+    "handlebars",
+    "utils"
+  ],
+  "author": "pasxd245",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nci-gis/js-tmpl.git"
+  },
+  "homepage": "https://github.com/nci-gis/js-tmpl#readme",
+  "bugs": {
+    "url": "https://github.com/nci-gis/js-tmpl/issues"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.0.0",
+    "pnpm": ">=10.0.0"
+  },
+  "dependencies": {
+    "config": "^4.1.1",
+    "handlebars": "^4.7.8",
+    "js-yaml": "^4.1.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "eslint": "^9.39.2",
+    "eslint-plugin-simple-import-sort": "^12.1.1"
+  },
+  "scripts": {
+    "test": "node --test $(find tests -name '*.test.js')",
+    "test:watch": "node --test --watch $(find tests -name '*.test.js')",
+    "test:coverage": "node --experimental-test-coverage --test $(find tests -name '*.test.js')",
+    "lint": "eslint src/ tests/",
+    "lint:fix": "eslint src/ tests/ --fix",
+    "build": "echo 'No build step required for pure JS library'",
+    "start": "node src/cli/main.js",
+    "help": "node src/cli/main.js --help",
+    "dev": "node src/cli/main.js",
+    "tool": "node src/cli/main.js"
+  }
+}

package/src/cli/args.js

@@ -0,0 +1,53 @@
+/**
+ * Parse CLI arguments.
+ * 
+ * @param {string[]} args
+ * @returns {Record<string, any>}
+ */
+export function parseArgs(args) {
+  const opts = { command: "render" };
+
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+
+    switch (a) {
+      case "render":
+        opts.command = "render";
+        break;
+
+      case "-t":
+      case "--template-dir":
+        opts.templateDir = args[++i];
+        break;
+
+      case "-c":
+      case "--values":
+        opts.valuesFile = args[++i];
+        break;
+
+      case "-o":
+      case "--out":
+        opts.outDir = args[++i];
+        break;
+
+      case "-p":
+      case "--partials-dir":
+        opts.partialsDir = args[++i];
+        break;
+
+      case "--config-file":
+        opts.configFile = args[++i];
+        break;
+
+      case "-x":
+      case "--ext":
+        opts.extname = args[++i];
+        break;
+    }
+    // next argument:
+    i++;
+  }
+
+  return opts;
+}

package/src/cli/main.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { resolveConfig } from "../config/resolver.js";
+import { renderDirectory } from "../engine/renderDirectory.js";
+import { parseArgs } from "./args.js";
+
+export async function main() {
+  const cli = parseArgs(process.argv);
+
+  if (cli.command !== "render") {
+    console.error("Unknown command:", cli.command);
+    process.exit(1);
+  }
+
+  const cfg = resolveConfig(cli);
+
+  await renderDirectory(cfg);
+
+  console.log("✔ js-tmpl completed.");
+}
+
+// Execute main function if this file is run directly
+try {
+  await main();
+} catch (error) {
+  console.error("Error:", error);
+  process.exit(1);
+}

package/src/config/defaults.js

@@ -0,0 +1,8 @@
+export const DEFAULTS = {
+  templateDir: "templates",
+  partialsDir: "templates.partials",
+  valuesDir: "templates.values",
+  valuesFile: "",
+  outDir: "dist",
+  extname: ".hbs",
+};

package/src/config/loader.js

@@ -0,0 +1,58 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import YAML from "js-yaml";
+
+/**
+ * Load YAML or JSON values.
+ *
+ * @param {string} filePath Path to YAML or JSON file.
+ * @returns {object} Parsed values.
+ */
+export function loadYamlOrJson(filePath) {
+  const raw = fs.readFileSync(filePath, "utf8");
+
+  if (/\.ya?ml$/i.test(filePath)) {
+    return YAML.load(raw) || {};
+  }
+  if (/\.json$/i.test(filePath)) {
+    return JSON.parse(raw);
+  }
+
+  throw new Error(`Unsupported values file: ${filePath}`);
+}
+
+/**
+ * Load js-tmpl project config from known locations.
+ *
+ * @param {string} cwd Current working directory.
+ * @param {string} [explicitFile] Explicit config file path.
+ * @returns {object|null} Parsed config object or null if not found.
+ */
+export function loadProjectConfig(cwd, explicitFile) {
+  const candidates = explicitFile
+    ? [explicitFile]
+    : [
+        "js-tmpl.config.yaml",
+        "js-tmpl.config.yml",
+        "js-tmpl.config.json",
+        path.join("config", "js-tmpl.yaml"),
+        path.join("config", "js-tmpl.json"),
+      ];
+
+  for (const rel of candidates) {
+    const abs = path.isAbsolute(rel) ? rel : path.join(cwd, rel);
+    if (!fs.existsSync(abs)) {continue;}
+
+    const raw = fs.readFileSync(abs, "utf8");
+
+    if (/\.ya?ml$/.test(abs)) {
+      return YAML.load(raw) || {};
+    }
+    if (/\.json$/.test(abs)) {
+      return JSON.parse(raw);
+    }
+  }
+
+  return null;
+}

package/src/config/resolver.js

@@ -0,0 +1,70 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+
+import { DEFAULTS } from "./defaults.js";
+import { loadProjectConfig,loadYamlOrJson } from "./loader.js";
+import { buildView } from "./view.js";
+
+/**
+ * Lookup default values file in valuesDir.
+ * Searches for: default.yaml, default.yml
+ *
+ * @param {string} valuesDir - Absolute path to values directory
+ * @returns {string|null} - Path to default values file or null if not found
+ */
+function lookupDefaultValuesFile(valuesDir) {
+  const candidates = ["default.yaml", "default.yml"];
+
+  for (const filename of candidates) {
+    const filepath = path.join(valuesDir, filename);
+    if (fs.existsSync(filepath)) {
+      return filepath;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Resolve final config using:
+ * defaults < projectConfig < cliArgs
+ *
+ * @param {object} cli - CLI arguments
+ * @param {string} cwd - Current working directory
+ * @returns {object} - Resolved configuration
+ */
+export function resolveConfig(cli, cwd = process.cwd()) {
+  const projectConfig = loadProjectConfig(cwd, cli.configFile);
+
+  const mergedConfig = {
+    ...DEFAULTS,
+    ...projectConfig,
+    ...cli,
+  };
+
+  const abs = (p) => (path.isAbsolute(p) ? p : path.join(cwd, p));
+
+  // If valuesFile not specified, try to find default.yaml in valuesDir
+  let valuesFile = mergedConfig.valuesFile;
+  if (!valuesFile) {
+    const valuesDir = abs(mergedConfig.valuesDir);
+    valuesFile = lookupDefaultValuesFile(valuesDir);
+
+    if (!valuesFile) {
+      throw new Error(
+        `Missing valuesFile. Use --values or create ${mergedConfig.valuesDir}/default.yaml`
+      );
+    }
+  }
+
+  const values = loadYamlOrJson(abs(valuesFile));
+
+  return {
+    templateDir: abs(mergedConfig.templateDir),
+    partialsDir: abs(mergedConfig.partialsDir),
+    outDir: abs(mergedConfig.outDir),
+    extname: mergedConfig.extname,
+    view: buildView(values),
+  };
+}

package/src/config/view.js

@@ -0,0 +1,6 @@
+export function buildView(values, env = process.env) {
+  return {
+    ...values,
+    env,
+  };
+}

package/src/engine/contentRenderer.js

@@ -0,0 +1,12 @@
+import fs from "node:fs/promises";
+
+import Handlebars from "handlebars";
+
+/**
+ * Render template file with Handlebars & view object.
+ */
+export async function renderContent(filePath, view) {
+  const raw = await fs.readFile(filePath, "utf8");
+  const compile = Handlebars.compile(raw);
+  return compile(view);
+}

package/src/engine/partials.js

@@ -0,0 +1,41 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import Handlebars from "handlebars";
+
+/**
+ * Register partials from a directory.
+ * - root partials use prefix "_"
+ * - group partials under "@group"
+ */
+export async function registerPartials(partialsDir, ext = ".hbs") {
+  const entries = await fs.readdir(partialsDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const abs = path.join(partialsDir, entry.name);
+
+    if (entry.isDirectory()) {
+      // handle namespacing
+      if (entry.name.startsWith("@")) {
+        const group = entry.name.slice(1);
+        const groupFiles = await fs.readdir(abs);
+
+        for (const f of groupFiles) {
+          if (!f.endsWith(ext)) {continue;}
+          const key = path.basename(f, ext);
+          const name = `${group}.${key}`;
+          const content = await fs.readFile(path.join(abs, f), "utf8");
+          Handlebars.registerPartial(name, content);
+        }
+      }
+      continue;
+    }
+
+    // root partial
+    if (entry.name.startsWith("_") && entry.name.endsWith(ext)) {
+      const content = await fs.readFile(abs, "utf8");
+      const key = entry.name.slice(1, -ext.length);
+      Handlebars.registerPartial(key, content);
+    }
+  }
+}

package/src/engine/pathRenderer.js

@@ -0,0 +1,20 @@
+import path from "node:path";
+
+import { getNested } from "../utils/object.js";
+
+/**
+ * Render `${var}` placeholders in each segment of the relPath.
+ */
+export function renderPath(relPath, view) {
+  const segments = relPath.split(path.sep);
+
+  const rendered = segments.map((seg) =>
+    //NOSONAR -- ignore S5842: Regular expression is safe here
+    seg.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+      const v = getNested(view, expr.trim());
+      return String(v ?? "");
+    })
+  );
+
+  return path.join(...rendered);
+}

package/src/engine/renderDirectory.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+
+import { ensureDir, writeFileSafe } from "../utils/fs.js";
+import { renderContent } from "./contentRenderer.js";
+import { registerPartials } from "./partials.js";
+import { renderPath } from "./pathRenderer.js";
+import { walkTemplateTree } from "./treeWalker.js";
+
+/**
+ * Main rendering orchestrator.
+ */
+export async function renderDirectory(cfg) {
+  const { templateDir, partialsDir, outDir, view, extname } = cfg;
+
+  await registerPartials(partialsDir, extname);
+
+  const files = await walkTemplateTree(templateDir, extname);
+
+  for (const file of files) {
+    const relRendered = renderPath(file.relPath, view);
+    const target = path.join(
+      outDir,
+      relRendered.replace(new RegExp(`${extname}$`), "")
+    );
+
+    const content = await renderContent(file.absPath, view);
+
+    await ensureDir(path.dirname(target));
+    await writeFileSafe(target, content);
+  }
+}

package/src/engine/treeWalker.js

@@ -0,0 +1,32 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * BFS async folder walker.
+ */
+export async function walkTemplateTree(rootDir, ext = ".hbs", ignore = []) {
+  const results = [];
+  const queue = [""];
+
+  while (queue.length) {
+    const rel = queue.shift();
+    const abs = path.join(rootDir, rel);
+    const stat = await fs.stat(abs);
+
+    if (stat.isDirectory()) {
+      const items = await fs.readdir(abs);
+      for (const name of items) {
+        if (ignore.some((i) => matchIgnore(name, i))) {continue;}
+        queue.push(rel ? path.join(rel, name) : name);
+      }
+    } else if (path.extname(abs) === ext) {
+      results.push({ absPath: abs, relPath: rel });
+    }
+  }
+
+  return results;
+}
+
+function matchIgnore(name, rule) {
+  return rule instanceof RegExp ? rule.test(name) : rule === name;
+}

package/src/index.js

@@ -0,0 +1,2 @@
+export * from "./config/resolver.js";
+export * from "./engine/renderDirectory.js";

package/src/utils/fs.js

@@ -0,0 +1,43 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+/** Safe mkdir -p
+ * @param {string} dir Directory path to create
+ */
+export async function ensureDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+
+/** Safe file write
+ * @param {string} file File path to write
+ * @param {string} content Content to write
+ */
+export async function writeFileSafe(file, content) {
+  await fs.writeFile(file, content, "utf8");
+}
+
+/** Resolve path relative to cwd
+ * @param {string} p Path to resolve
+ * @param {string} cwd Current working directory
+ * @returns {string} Resolved path
+ */
+export function resolvePath(p, cwd = process.cwd()) {
+  return path.isAbsolute(p) ? p : path.join(cwd, p);
+}
+
+/**
+ * Safely resolve a path.
+ * If the first segment is absolute, resolves from that segment.
+ * Otherwise resolves relative to process.cwd().
+ * Does not perform sanitization; caller must ensure inputs are trusted.
+ *
+ * @param {...string} segments Path segments to join.
+ * @returns {string} Absolute path.
+ */
+export function safeResolvePath(...segments) {
+  const isAbsolute = segments ? segments[0] && path.isAbsolute(segments[0]) : false;
+  if (isAbsolute) {
+    return path.resolve(...segments);
+  }
+  return path.resolve(process.cwd(), ...segments);
+}

package/src/utils/object.js

@@ -0,0 +1,10 @@
+/**
+ * Retrieve nested value: getNested(obj, "a.b.c")
+ */
+export function getNested(obj, key) {
+  console.log("getNested", obj, key);
+  
+  return key
+    .split(".")
+    .reduce((acc, k) => (acc?.[k] ?? undefined), obj);
+}