chore(release): 1.5.0-develop.3 [skip ci]

## [1.5.0-develop.3](https://github.com/chenasraf/simple-scaffold/compare/v1.5.0-develop.2...v1.5.0-develop.3) (2023-05-04)

### Features

* node.js function for remote configs ([7e9022f](7e9022f433))

.editorconfig

@@ -0,0 +1,8 @@
+[*]
+tab_width = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false

.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: chenasraf
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: casraf
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom:
+  - "https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=TSH3C3ABGQM22&currency_code=ILS&source=url"

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,47 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[BUG] "
+labels: bug, needs-triage
+assignees: chenasraf
+---
+
+#### Describe the bug
+
+A clear and concise description of what the bug is.
+
+#### How To Reproduce
+
+Steps to reproduce the behavior:
+
+1. Prepare templates:
+
+   ```text
+   This is my {{ template }}
+   ```
+
+2. Run with args/config:
+
+   ```shell
+   npx simple-scaffold@latest -t input -o output TplName
+   ```
+
+#### Expected behavior\*\*
+
+A clear and concise description of what you expected to happen.
+
+#### Logs
+
+If applicable, paste your logs to help explain your problem. To see more logs, run the scaffold with
+`-v 1` to enable debug logging.
+
+#### Desktop (please complete the following information):
+
+- OS: [e.g. macOS, Windows, Linux]
+- OS Version: [e.g. Big Sur, 11, Ubuntu 20.04]
+- Node.js: [e.g. 16.8]
+- Simple Scaffold Version [e.g. 1.1.2]
+
+#### Additional context
+
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,24 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: "[FEATURE] "
+labels: enhancement, needs-triage
+assignees: chenasraf
+---
+
+#### Is your feature request related to a problem? Please describe.
+
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+#### Describe the solution you'd like
+
+A clear and concise description of what you want to happen.
+
+#### Describe alternatives you've considered
+
+A clear and concise description of any alternative solutions or features you've considered, if
+applicable.
+
+#### Additional context
+
+Add any other context or screenshots about the feature request here.

.github/workflows/docs.yml

@@ -0,0 +1,21 @@
+name: Documentation
+
+on:
+  push:
+    branches: [ master, develop ]
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    # if: "!contains(github.event.head_commit.message, '[skip ci]') && !contains(github.event.head_commit.message, '[skip docs]')"
+    if: "!contains(github.event.head_commit.message, '[skip docs]')"
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: "18.x"
+      - run: yarn install --frozen-lockfile
+      - run: yarn build-docs
+      - uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./docs

.github/workflows/pull_requests.yml

@@ -0,0 +1,17 @@
+name: Pull Requests
+
+on:
+  pull_request:
+    branches: [master, develop]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    if: "!contains(github.event.head_commit.message, '[skip ci]')"
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: "18.x"
+      - run: yarn install --frozen-lockfile
+      - run: yarn build
+      - run: yarn test

.github/workflows/release.yml

@@ -0,0 +1,34 @@
+name: Test & Build
+
+on:
+  push:
+    branches: [ master, develop, feat/*, fix/* ]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    if: "!contains(github.event.head_commit.message, '[skip ci]')"
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: "18.x"
+      - run: yarn install --frozen-lockfile
+      - run: yarn test
+        if: "!contains(github.event.head_commit.message, '[skip test]')"
+  build:
+    runs-on: ubuntu-latest
+    if: "!contains(github.event.head_commit.message, '[skip ci]')"
+    needs: test
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: "18.x"
+      - run: yarn install --frozen-lockfile
+      - run: yarn build
+      - run: cd ./dist && yarn pack --filename=../package.tgz
+      - run: yarn semantic-release
+        if: "!contains(github.event.head_commit.message, '[skip publish]')"
+        env:
+          NPM_TOKEN: "${{ secrets.NPM_TOKEN }}"
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"

.gitignore

@@ -42,6 +42,9 @@ typings/
 # Optional npm cache directory
 .npm
 
+# NPM
+.npmrc
+
 # Optional eslint cache
 .eslintcache
 
@@ -57,4 +60,9 @@ typings/
 # dotenv environment variables file
 .env
 
-examples/test-output
+examples/test-output/**/*
+dist/
+.DS_Store
+tmp/
+docs/
+.nvmrc

.markdownlint.json

@@ -0,0 +1,9 @@
+{
+  "line-length": {
+    "line_length": 100,
+    "tables": false,
+    "code_blocks": false
+  },
+  "no-inline-html": false,
+  "first-line-h1": false
+}

.prettierrc

@@ -0,0 +1,15 @@
+{
+  "semi": false,
+  "trailingComma": "all",
+  "printWidth": 120,
+  "tabWidth": 2,
+  "overrides": [
+    {
+      "files": "*.md",
+      "options": {
+        "printWidth": 100,
+        "proseWrap": "always"
+      }
+    }
+  ]
+}

.vscode/launch.json

@@ -1,21 +1,27 @@
 {
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-      {
-        "type": "node",
-        "request": "attach",
-        "name": "Attach by Process ID",
-        "processId": "${command:PickProcess}"
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Debug Scaffold",
+      "type": "node",
+      "request": "launch",
+      "protocol": "inspector",
+      "cwd": "${workspaceFolder}",
+      "program": "${workspaceFolder}/test.ts",
+      "outFiles": ["${workspaceRoot}/dist/test.js"],
+      "env": {
+        "NODE_ENV": "develop"
       },
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "Debug Scaffold",
-            "protocol": "inspector",
-            "program": "${workspaceFolder}/dist/scaffold.js"
-        }
-    ]
+      "sourceMaps": true
+    },
+    {
+      "type": "node",
+      "request": "attach",
+      "name": "Attach by Process ID",
+      "processId": "${command:PickProcess}"
+    }
+  ]
 }

.vscode/settings.json

@@ -0,0 +1,22 @@
+{
+  "typescript.tsdk": "./node_modules/typescript/lib",
+  "npm.packageManager": "yarn",
+  "cSpell.words": [
+    "massarg",
+    "MYCOMPONENT",
+    "myname",
+    "nobrace",
+    "nocomment",
+    "nodir",
+    "noext",
+    "nonegate",
+    "subdir",
+    "variabletoken"
+  ],
+  "[markdown]": {
+    "editor.rulers": [
+      87,
+      100
+    ],
+  },
+}

.vscode/tasks.json

@@ -0,0 +1,59 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "script": "build",
+      "label": "build",
+      "type": "npm",
+      "problemMatcher": []
+    },
+    {
+      "script": "dev",
+      "label": "dev",
+      "type": "npm",
+      "problemMatcher": []
+    },
+    {
+      "command": "yarn typedoc --watch",
+      "label": "typedoc --watch",
+      "type": "shell",
+      "problemMatcher": []
+    },
+    {
+      "script": "start",
+      "label": "start",
+      "type": "npm",
+      "problemMatcher": []
+    },
+    {
+      "script": "test",
+      "label": "test",
+      "type": "npm",
+      "problemMatcher": []
+    },
+    {
+      "command": "yarn test --watchAll",
+      "label": "yarn test --watchAll",
+      "type": "shell",
+      "problemMatcher": []
+    },
+    {
+      "script": "cmd",
+      "label": "cmd",
+      "type": "npm",
+      "problemMatcher": []
+    },
+    {
+      "script": "build-test",
+      "label": "build-test",
+      "type": "npm",
+      "problemMatcher": []
+    },
+    {
+      "script": "build-cmd",
+      "label": "build-cmd",
+      "type": "npm",
+      "problemMatcher": []
+    }
+  ]
+}

CHANGELOG.md

@@ -0,0 +1,157 @@
+# Change Log
+
+## [1.5.0-develop.3](https://github.com/chenasraf/simple-scaffold/compare/v1.5.0-develop.2...v1.5.0-develop.3) (2023-05-04)
+
+
+### Features
+
+* node.js function for remote configs ([7e9022f](https://github.com/chenasraf/simple-scaffold/commit/7e9022f4331c8a1351642042c0215f9160b2768a))
+
+## [1.5.0-develop.2](https://github.com/chenasraf/simple-scaffold/compare/v1.5.0-develop.1...v1.5.0-develop.2) (2023-05-03)
+
+
+### Bug Fixes
+
+* move dependency to dev dependency ([408a940](https://github.com/chenasraf/simple-scaffold/commit/408a94085366bb4e39391fcfcfa7df78b06a480f))
+
+## [1.5.0-develop.1](https://github.com/chenasraf/simple-scaffold/compare/v1.4.0...v1.5.0-develop.1) (2023-05-02)
+
+
+### Features
+
+* add github remote templates ([f961c13](https://github.com/chenasraf/simple-scaffold/commit/f961c13da15320b42540773ed958cdc3f97e4502))
+* support for remote template configs ([05487f4](https://github.com/chenasraf/simple-scaffold/commit/05487f4d1e3b05f1d695242bb54427ee2fbdf247))
+
+## [1.4.0](https://github.com/chenasraf/simple-scaffold/compare/v1.3.2...v1.4.0) (2023-04-28)
+
+
+### Features
+
+* add `--key` | `-k` to config loader ([6c5ba0b](https://github.com/chenasraf/simple-scaffold/commit/6c5ba0bc916fb1d59240d2eaa1abedc74527a974))
+
+## [1.3.2](https://github.com/chenasraf/simple-scaffold/compare/v1.3.1...v1.3.2) (2023-04-28)
+
+
+### Bug Fixes
+
+* release build ([2c23fa9](https://github.com/chenasraf/simple-scaffold/commit/2c23fa9dbb310cd0a31f09606798f96b95d66779))
+* release build asset ([0bef2df](https://github.com/chenasraf/simple-scaffold/commit/0bef2df5f3aa800ad5f1094c0996108db9acce51))
+
+## [1.3.1](https://github.com/chenasraf/simple-scaffold/compare/v1.3.0...v1.3.1) (2023-04-28)
+
+
+### Bug Fixes
+
+* docs ([6e19a86](https://github.com/chenasraf/simple-scaffold/commit/6e19a86190dd924058a48448aa6463569ef1125f))
+* remove old peer-dep ([c7e2ef8](https://github.com/chenasraf/simple-scaffold/commit/c7e2ef862cb658feb1071ac120b185d8b34d6dd3))
+
+## [1.3.0](https://github.com/chenasraf/simple-scaffold/compare/v1.2.0...v1.3.0) (2023-04-25)
+
+### Features
+
+- load scaffold config from files
+  ([c398976](https://github.com/chenasraf/simple-scaffold/commit/c3989769fee445c9183ff5e5b3892c4e9fb66a9e))
+
+### Bug Fixes
+
+- config option should not be mandatory
+  ([3db6a91](https://github.com/chenasraf/simple-scaffold/commit/3db6a918f13d9300efa2fcb4a356d004475ab91c))
+- export config file type
+  ([4302eb5](https://github.com/chenasraf/simple-scaffold/commit/4302eb5ce35ed6cf1dc80dfb92790c3fdd96f963))
+
+## [1.2.0](https://github.com/chenasraf/simple-scaffold/compare/v1.1.4...v1.2.0) (2023-04-24)
+
+### Features
+
+- append-data cli flag
+  ([3c5c2de](https://github.com/chenasraf/simple-scaffold/commit/3c5c2ded02f61ff086e81ea4a7f40529bdff1c9d))
+
+### Bug Fixes
+
+- ci node version
+  ([767d34c](https://github.com/chenasraf/simple-scaffold/commit/767d34c684516d4cea865b25e87c27c779bb79ce))
+- semantic-release build dir
+  ([f7956dd](https://github.com/chenasraf/simple-scaffold/commit/f7956ddc786018905c48ccf1f21a3bb4657c3d75))
+- support quote wrapping in append-data
+  ([4fecca8](https://github.com/chenasraf/simple-scaffold/commit/4fecca848347312d45d704f82f2bcb3822da9b06))
+
+## [1.1.4](https://github.com/chenasraf/simple-scaffold/compare/v1.1.3...v1.1.4) (2023-03-13)
+
+### Bug Fixes
+
+- github action node version
+  ([7c19c53](https://github.com/chenasraf/simple-scaffold/commit/7c19c533376dc6904231e5cc51c7a4b2658c66e0))
+- github action node version
+  ([94fec76](https://github.com/chenasraf/simple-scaffold/commit/94fec766165f7540c578dbf2d0aeeb6ea3969ad8))
+
+### Misc
+
+- update typedoc version
+  ([c334396](https://github.com/chenasraf/simple-scaffold/commit/c334396d74414cbe0aba305c66dfad7fdeb88669))
+- update dependencies
+  ([20400bd](https://github.com/chenasraf/simple-scaffold/commit/20400bd81dd43d457427675286c9964a8bc0d5f6))
+- bump version number
+  ([8e432bf](https://github.com/chenasraf/simple-scaffold/commit/8e432bfb0b410dc0655c3924031bea2648a42ad0))
+
+## [1.1.3](https://github.com/chenasraf/simple-scaffold/compare/v1.1.2...v1.1.3) (2023-03-11)
+
+### Bug Fixes
+
+- base path
+  ([943717a](https://github.com/chenasraf/simple-scaffold/commit/943717a76998ec0609f2072c886df6b4775f2ea2))
+- binary files + add tests
+  ([e450ad2](https://github.com/chenasraf/simple-scaffold/commit/e450ad242ed70ae928b19964da38cdcb1b6cf659))
+
+## [1.1.0](https://github.com/chenasraf/simple-scaffold/compare/v1.0.4...v1.1.0) (2022-04-21)
+
+## [1.0.3](https://github.com/chenasraf/simple-scaffold/compare/v1.0.2...v1.0.3) (2022-03-03)
+
+## [1.0.1-pre.1](https://github.com/chenasraf/simple-scaffold/compare/v1.0.0...v1.0.1-pre.1) (2022-02-17)
+
+## [0.7.5](https://github.com/chenasraf/simple-scaffold/compare/v0.7.4...v0.7.5) (2021-09-26)
+
+## [0.7.4](https://github.com/chenasraf/simple-scaffold/compare/v0.7.3...v0.7.4) (2021-09-26)
+
+## [0.7.3](https://github.com/chenasraf/simple-scaffold/compare/v0.7.2...v0.7.3) (2021-09-26)
+
+## [0.7.2](https://github.com/chenasraf/simple-scaffold/compare/v0.6.1...v0.7.2) (2021-04-19)
+
+## [0.6.1](https://github.com/chenasraf/simple-scaffold/compare/v0.6.0...v0.6.1) (2021-02-01)
+
+### Bug Fixes
+
+- binary files
+  ([7c0c347](https://github.com/chenasraf/simple-scaffold/commit/7c0c3470020d7c166ea68a8effa6df65ec38f2c8))
+
+## [0.6.0](https://github.com/chenasraf/simple-scaffold/compare/v0.5.0...v0.6.0) (2021-02-01)
+
+### Bug Fixes
+
+- support deeper file structure
+  ([4afafa5](https://github.com/chenasraf/simple-scaffold/commit/4afafa5a4af2e3f4b0af54f20811ecb2c8d98560))
+
+## [0.5.0](https://github.com/chenasraf/simple-scaffold/compare/v0.4.5...v0.5.0) (2019-02-27)
+
+## [0.4.5](https://github.com/chenasraf/simple-scaffold/compare/v0.4.4...v0.4.5) (2019-02-27)
+
+## [0.4.4](https://github.com/chenasraf/simple-scaffold/compare/v0.4.3...v0.4.4) (2019-02-27)
+
+## [0.4.3](https://github.com/chenasraf/simple-scaffold/compare/v0.4.2...v0.4.3) (2019-02-27)
+
+## [0.4.2](https://github.com/chenasraf/simple-scaffold/compare/v0.4.1...v0.4.2) (2019-02-25)
+
+## [0.4.1](https://github.com/chenasraf/simple-scaffold/compare/v0.3.1...v0.4.1) (2019-02-25)
+
+## [0.3.1](https://github.com/chenasraf/simple-scaffold/compare/v0.3.0...v0.3.1) (2018-01-15)
+
+## [0.3.0](https://github.com/chenasraf/simple-scaffold/compare/v0.2.0...v0.3.0) (2018-01-15)
+
+## [0.2.0](https://github.com/chenasraf/simple-scaffold/compare/v0.1.5...v0.2.0) (2018-01-05)
+
+## [0.1.5](https://github.com/chenasraf/simple-scaffold/compare/v0.1.4...v0.1.5) (2018-01-01)
+
+## [0.1.4](https://github.com/chenasraf/simple-scaffold/compare/v0.1.3...v0.1.4) (2018-01-01)
+
+## [0.1.3](https://github.com/chenasraf/simple-scaffold/compare/v0.1.2...v0.1.3) (2018-01-01)
+
+## 0.1.2 (2018-01-01)

README.md

@@ -1,12 +1,154 @@
-# scaffolder
-Scaffolder allows you to create your structured files based on templates.
+<h1 align="center">Simple Scaffold</h1>
 
-### How to use
+<h2 align="center">
 
-#### Install
-You Scaffolder by using `npm`. Global flag is useful if you want easy cli access to it.
+[GitHub](https://github.com/chenasraf/simple-scaffold) |
+[Documentation](https://chenasraf.github.io/simple-scaffold) |
+[NPM](https://npmjs.com/package/simple-scaffold) | [casraf.dev](https://casraf.dev)
 
-```
-npm install -g scaffolder
+![version](https://img.shields.io/github/package-json/v/chenasraf/simple-scaffold/master?label=version)
+![build](https://img.shields.io/github/actions/workflow/status/chenasraf/simple-scaffold/release.yml?branch=master)
+
+</h2>
+
+Looking to streamline your workflow and get your projects up and running quickly? Look no further
+than Simple Scaffold - the easy-to-use NPM package that simplifies the process of organizing and
+copying your commonly-created files.
+
+With its agnostic and un-opinionated approach, Simple Scaffold can handle anything from a few simple
+files to an entire app boilerplate setup. Plus, with the power of **Handlebars.js** syntax, you can
+easily replace custom data and personalize your files to fit your exact needs. But that's not all -
+you can also use it to loop through data, use conditions, and write custom functions using helpers.
+
+Don't waste any more time manually copying and pasting files - let Simple Scaffold do the heavy
+lifting for you and start building your projects faster and more efficiently today!
+
+<div align="center">
+
+![sample animation](media/intro.gif)
+
+</div>
+
+---
+
+## Quick Start
+
+### Local Templates
+
+The fastest way to get started is to use `npx` to immediately start a scaffold process.
+
+Prepare any templates you want to use - for example, in the directory `templates/component`; and use
+that in the CLI args. Here is a simple example file:
+
+`templates/component/{{ pascalName name }}.tsx`
+
+```tsx
+// Created: {{ now | 'yyyy-MM-dd' }}
+import React from 'react'
+
+export default {{pascalCase name}}: React.FC = (props) => {
+  return (
+    <div className="{{camelCase name}}">{{pascalCase name}} Component</div>
+  )
+}
 ```
 
+To generate the template output, run:
+
+```shell
+# generate single component
+npx simple-scaffold@latest \
+  -t templates/component -o src/components PageWrapper
+```
+
+This will immediately create the following file: `src/components/PageWrapper.tsx`
+
+```tsx
+// Created: 2077/01/01
+import React from 'react'
+
+export default PageWrapper: React.FC = (props) => {
+  return (
+    <div className="pageWrapper">PageWrapper Component</div>
+  )
+}
+```
+
+### Remote Templates
+
+Another quick way to start is to re-use someone else's (or your own) work using a template
+repository.
+
+Here is an example for loading the example component templates in this very repository:
+
+```shell
+npx simple-scaffold@latest \
+  -gh chenasraf/simple-scaffold#examples/test-input/scaffold.config.js:component \
+  PageWrapper
+
+# equivalent to:
+npx simple-scaffold@latest \
+  -c https://github.com/chenasraf/simple-scaffold.git#examples/test-input/scaffold.config.js:component \
+  PageWrapper
+```
+
+When template name (`:component`) is omitted, `default` is used.
+
+See more at the [CLI documentation](https://chenasraf.github.io/simple-scaffold/pages/cli.html)
+
+## Documentation
+
+See full documentation [here](https://chenasraf.github.io/simple-scaffold).
+
+- [Command Line Interface (CLI) usage](https://chenasraf.github.io/simple-scaffold/pages/cli.html)
+- [Node.js usage](https://chenasraf.github.io/simple-scaffold/pages/node.html)
+- [Templates](https://chenasraf.github.io/simple-scaffold/pages/templates.html)
+- [Configuration Files](https://chenasraf.github.io/simple-scaffold/pages/configuration_files.html)
+- [Migrating v0.x to v1.x](https://chenasraf.github.io/simple-scaffold/pages/migration.html)
+
+## Contributing
+
+I am developing this package on my free time, so any support, whether code, issues, or just stars is
+very helpful to sustaining its life. If you are feeling incredibly generous and would like to donate
+just a small amount to help sustain this project, I would be very very thankful!
+
+<a href='https://ko-fi.com/casraf' target='_blank'>
+  <img height='36' style='border:0px;height:36px;'
+    src='https://cdn.ko-fi.com/cdn/kofi1.png?v=3'
+    alt='Buy Me a Coffee at ko-fi.com' />
+</a>
+
+I welcome any issues or pull requests on GitHub. If you find a bug, or would like a new feature,
+don't hesitate to open an appropriate issue and I will do my best to reply promptly.
+
+If you are a developer and want to contribute code, here are some starting tips:
+
+1. Fork this repository
+2. Run `yarn install`
+3. Run `yarn dev` to start file watch mode
+4. Make any changes you would like
+5. Create tests for your changes
+6. Update the relevant documentation (readme, code comments, type comments)
+7. Create a PR on upstream
+
+Some tips on getting around the code:
+
+- Use `yarn dev` for development - it runs TypeScript compile in watch mode, allowing you to make
+  changes and immediately be able to try them using `yarn cmd`.
+- Use `yarn build` to build the output once
+- Use `yarn test` to run tests
+- Use `yarn cmd` to use the CLI feature of Simple Scaffold from within the root directory, enabling
+  you to test different behaviors. See `yarn cmd -h` for more information.
+
+  > This requires an updated build, and does not trigger one itself. From here you have several
+  > options:
+  >
+  > - Run `yarn dev` to watch for file changes and build automatically
+  > - Run `yarn build` before running this to trigger a one-time build
+  > - Run `yarn build-cmd` which triggers a build right before running `yarn cmd` automatically with
+  >   the rest of the given arguments.
+
+- Use `yarn build-docs` to build the documentation once
+- Use `yarn watch-docs` to start docs in watch mode
+- To see the documentation, currently you have to serve the directory yourself with a static web
+  server (like node's built in serve, VS code's "Go Live" mode, etc)

dist/scaffold.js

@@ -1 +0,0 @@
-!function(t){function e(n){if(o[n])return o[n].exports;var i=o[n]={i:n,l:!1,exports:{}};return t[n].call(i.exports,i,i.exports,e),i.l=!0,i.exports}var o={};e.m=t,e.c=o,e.d=function(t,o,n){e.o(t,o)||Object.defineProperty(t,o,{configurable:!1,enumerable:!0,get:n})},e.n=function(t){var o=t&&t.__esModule?function(){return t.default}:function(){return t};return e.d(o,"a",o),o},e.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},e.p="",e(e.s=0)}([function(t,e,o){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var n=o(1),i=(o.n(n),o(2)),s=(o.n(i),function(){function t(t){if(this.locals={},this.scaffoldName=process.argv[2],this.DefaultConfig={templates:[],output:i.resolve(process.cwd()),locals:{Name:this.scaffoldName[0].toUpperCase()+this.scaffoldName.slice(1),name:this.scaffoldName[0].toLowerCase()+this.scaffoldName.slice(1)}},!this.scaffoldName)throw new Error("Must provide scaffold name");this.config=Object.assign({},this.DefaultConfig,t),this.locals=Object.assign({},this.DefaultConfig.locals,t.locals),console.info("Config loaded:",this.config),console.info("Locals:",this.locals)}return t.prototype.parseLocals=function(t){var e=this,o=t.toString(),n=/{[%]\s*([^%{}]+)\s*[%]}/gi;return o.replace(n,function(t,o){return e.locals[o]})},t.prototype.getFileList=function(t){var e=this,o=[];return t.forEach(function(t){var s=n.lstatSync(t);if(s.isFile())console.info("pushing",t),o.push(t);else if(s.isDirectory()){console.info("going into dir",t);var r=n.readdirSync(t).map(function(e){return i.join(t,e)});o=o.concat(e.getFileList(r))}}),o},t.prototype.getFileContents=function(t){return n.readFileSync(t).toString()},t.prototype.getOutputPath=function(t){var e;return e="function"==typeof this.config.output?this.config.output(t):this.config.output+"/"+this.scaffoldName+"/"+i.basename(t),this.parseLocals(e)},t.prototype.writeFile=function(t,e){n.existsSync(i.dirname(t))||n.mkdirSync(i.dirname(t)),console.info("Writing file:",t),n.writeFileSync(t,e,{encoding:"utf-8"})},t.prototype.run=function(){var t=this,e=this.getFileList(this.config.templates);console.info(e),e.forEach(function(e){var o=t.getOutputPath(e),n=t.getFileContents(e),i=t.parseLocals(n);t.writeFile(o,i)})},t}());exports.default=s},function(t,e){t.exports=require("fs")},function(t,e){t.exports=require("path")}]);

examples/test-input/Component/inner/inner-{{name}}.txt

@@ -0,0 +1 @@
+{{name}}

examples/test-input/Component/{%Name%}.tsx

@@ -1,13 +0,0 @@
-import * as React from 'react'
-
-class {%Name%} extends React.Component {
-  private {%property%}
-
-  constructor() {
-    this.{%property%} = {%value%}
-  }
-
-  <div className={css.{%Name%}} />
-}
-
-export default {%Name%}

examples/test-input/Component/{{Name}}.tsx

@@ -0,0 +1,17 @@
+import * as React from "react"
+import * as css from "./{{Name}}.css"
+
+class {{Name}} extends React.Component<any> {
+  private {{ property }}
+
+  constructor(props: any) {
+    super(props)
+    this.{{ property }} = {{ value }}
+  }
+
+  public render() {
+    return <div className={ css.{{Name}} } />
+  }
+}
+
+export default {{Name}}

examples/test-input/scaffold.config.js

@@ -0,0 +1,13 @@
+/** @type {import('simple-scaffold').ScaffoldConfigFile} */
+module.exports = {
+  default: {
+    templates: ["examples/test-input/Component"],
+    output: "examples/test-output",
+    data: { property: "myProp", value: "10" },
+  },
+  component: {
+    templates: ["examples/test-input/Component"],
+    output: "examples/test-output/component",
+    data: { property: "myProp", value: "10" },
+  },
+}

index.d.ts

@@ -1,15 +0,0 @@
-export namespace IScaffold {
-
-  export interface IConfig {
-    templates: string[]
-    output: string | ((path: string) => string)
-    locals?: any
-  }
-
-  export interface IReplacement {
-    find: string | RegExp
-    replace(): string
-    [other: string]: any
-  }
-
-}

jest.config.ts

@@ -0,0 +1,205 @@
+/*
+ * For a detailed explanation regarding each configuration property and type check, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+export default {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/private/var/folders/q9/0mns8fgd00b4t5j5lq2wh2yh0000gn/T/jest_dx",
+
+  // Automatically clear mock calls, instances, contexts and results before every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: "coverage",
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  coverageProvider: "v8",
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // The default configuration for fake timers
+  // fakeTimers: {
+  //   "enableGlobally": false
+  // },
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "mjs",
+  //   "cjs",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+  // moduleNameMapper: {
+  //   chalk: "<rootDir>/node_modules/chalk/source/index.js",
+  //   "#ansi-styles": "<rootDir>/node_modules/chalk/source/vendor/ansi-styles/index.js",
+  //   "#supports-color": "<rootDir>/node_modules/chalk/source/vendor/supports-color/index.js",
+  // },
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  modulePathIgnorePatterns: ["<rootDir>/dist"],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  preset: "ts-jest",
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state before every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state and implementation before every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  // testEnvironment: "jest-environment-node",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).[tj]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // A map from regular expressions to paths to transformers
+  // transform: undefined,
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "/node_modules/",
+  //   "\\.pnp\\.[^\\/]+$"
+  // ],
+
+  // transform: {
+  //   "^.+\\.ts?$": "ts-jest",
+  // },
+  // transformIgnorePatterns: ["<rootDir>/node_modules/"],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+}

package.json

@@ -1,26 +1,66 @@
 {
   "name": "simple-scaffold",
-  "version": "0.1.4",
-  "description": "Create files based on templates",
+  "version": "1.5.0",
+  "description": "A simple command to generate any file structure, from single components to entire app boilerplates.",
+  "homepage": "https://chenasraf.github.io/simple-scaffold",
   "repository": "https://github.com/chenasraf/simple-scaffold.git",
   "author": "Chen Asraf <inbox@casraf.com>",
   "license": "MIT",
-  "main": "dist/scaffold.js",
-  "bin": "dist/scaffold.js",
-  "scripts": {
-    "build": "webpack -p && chmod +x dist/scaffold.js",
-    "dev": "webpack --watch",
-    "start": "node dist/scaffold.js",
-    "test": "yarn build && node scripts/test.js"
-  },
-  "files": [
-    "dist/scaffold.js"
+  "main": "index.js",
+  "bin": "cmd.js",
+  "keywords": [
+    "javascript",
+    "cli",
+    "template",
+    "files",
+    "typescript",
+    "generator",
+    "scaffold",
+    "file",
+    "scaffolding"
   ],
+  "scripts": {
+    "clean": "rimraf dist/",
+    "build": "yarn clean && tsc && chmod -R +x ./dist && cp ./package.json ./README.md ./dist/",
+    "dev": "tsc --watch",
+    "start": "node dist/scaffold.js",
+    "test": "jest",
+    "cmd": "node --trace-warnings dist/cmd.js",
+    "build-test": "yarn build && yarn test",
+    "build-cmd": "yarn build && yarn cmd",
+    "build-docs": "typedoc",
+    "watch-docs": "yarn typedoc --watch",
+    "audit-fix": "npm_config_yes=true npx yarn-audit-fix --flow=convert",
+    "changelog": "conventional-changelog -p conventionalcommits -i CHANGELOG.md -s -r 0"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "date-fns": "^2.29.3",
+    "glob": "^9.2.1",
+    "handlebars": "^4.7.7",
+    "lodash": "^4.17.21",
+    "massarg": "^1.0.7-pre.1"
+  },
   "devDependencies": {
-    "@types/node": "^8.0.50",
-    "ts-loader": "^3.1.1",
-    "typescript": "^2.6.1",
-    "webpack": "^3.8.1",
-    "webpack-dev-server": "^2.9.4"
+    "@knodes/typedoc-plugin-pages": "^0.23.4",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/release-notes-generator": "^10.0.3",
+    "@types/jest": "^29.5.1",
+    "@types/lodash": "^4.14.171",
+    "@types/mock-fs": "^4.13.1",
+    "@types/node": "^18.16.0",
+    "conventional-changelog": "^3.1.25",
+    "conventional-changelog-cli": "^2.2.2",
+    "conventional-changelog-conventionalcommits": "^5.0.0",
+    "jest": "^29.5.0",
+    "mock-fs": "^5.2.0",
+    "rimraf": "^5.0.0",
+    "semantic-release": "^21.0.1",
+    "semantic-release-conventional-commits": "^3.0.0",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "typedoc": "^0.24.6",
+    "typescript": "^5.0.4"
   }
 }

pages/README.md

@@ -0,0 +1,7 @@
+See full documentation [here](https://chenasraf.github.io/simple-scaffold).
+
+- [Command Line Interface (CLI) usage](https://chenasraf.github.io/simple-scaffold/pages/cli.html)
+- [Node.js usage](https://chenasraf.github.io/simple-scaffold/pages/node.html)
+- [Templates](https://chenasraf.github.io/simple-scaffold/pages/templates.html)
+- [Configuration Files](https://chenasraf.github.io/simple-scaffold/pages/configuration_files.html)
+- [Migrating v0.x to v1.x](https://chenasraf.github.io/simple-scaffold/pages/migration.html)

pages/cli.md

@@ -0,0 +1,79 @@
+## Available flags
+
+```text
+Usage: simple-scaffold [options]
+```
+
+To see this and more information anytime, add the `-h` or `--help` flag to your call, e.g.
+`npx simple-scaffold@latest -h`.
+
+| Command \| alias                  |                                                                                                                                                                                                     |
+| --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--help`\|`-h`                    | Display help information                                                                                                                                                                            |
+| `--name`\|`-n`                    | Name to be passed to the generated files. {{name}} and {{Name}} inside contents and file names will be replaced accordingly.                                                                        |
+| `--config`\|`-c`                  | Filename or HTTPS git URL to load config from instead of passing arguments to CLI or using a Node.js script.                                                                                        |
+| `--github`\|`-gh`                 | GitHub path to load config from instead of passing arguments to CLI or using a Node.js script.                                                                                                      |
+| `--key`\|`-k`                     | Key to load inside the config file. This overwrites the config key provided after the colon in --config (e.g. --config scaffold.cmd.js:component)                                                   |
+| `--output`\|`-o`                  | Path to output to. If --create-sub-folder is enabled, the subfolder will be created inside this path. (default: current dir)                                                                        |
+| `--templates`\|`-t`               | Template files to use as input. You may provide multiple files, each of which can be a relative or absolute path, or a glob pattern for multiple file matching easily.                              |
+| `--overwrite`\|`-w`               | Enable to override output files, even if they already exist. (default: false)                                                                                                                       |
+| `--data`\|`-d`                    | Add custom data to the templates. By default, only your app name is included.                                                                                                                       |
+| `--append-data`\|`-D`             | Append additional custom data to the templates, which will overwrite --data, using an alternate syntax, which is easier to use with CLI: -D key1=string -D key2:=raw                                |
+| `--create-sub-folder`\|`-s`       | Create subfolder with the input name (default: false)                                                                                                                                               |
+| `--sub-folder-name-helper`\|`-sh` | Default helper to apply to subfolder name when using `--create-sub-folder true`.                                                                                                                    |
+| `--quiet`\|`-q`                   | Suppress output logs (Same as --verbose 0) (default: false)                                                                                                                                         |
+| `--verbose`\|`-v`                 | Determine amount of logs to display. The values are: 0 (none) \| 1 (debug) \| 2 (info) \| 3 (warn) \| 4 (error). The provided level will display messages of the same level or higher. (default: 2) |
+| `--dry-run`\|`-dr`                | Don't emit files. This is good for testing your scaffolds and making sure they don't fail, without having to write actual file contents or create directories. (default: false)                     |
+
+## Examples:
+
+> See
+> [Configuration Files](https://chenasraf.github.io/simple-scaffold/pages/docs/configuration_files.md)
+> for organizing multiple scaffold types into easy-to-maintain files
+
+Usage with config file
+
+```shell
+$ simple-scaffold -c scaffold.cmd.js --key component
+```
+
+Usage with GitHub config file
+
+```shell
+$ simple-scaffold -gh chenasraf/simple-scaffold --key component
+```
+
+Usage with https git URL (for non-GitHub)
+
+```shell
+$ simple-scaffold -c \
+      https://example.com/user/template.git#scaffold.cmd.js --key component
+```
+
+Full syntax with config path and template key (applicable to all above methods)
+
+```shell
+$ simple-scaffold -c scaffold.cmd.js:component MyComponent
+```
+
+Excluded template key, assumes 'default' key
+
+```shell
+$ simple-scaffold -c scaffold.cmd.js MyComponent
+```
+
+Shortest syntax for GitHub, assumes file 'scaffold.cmd.js' and template key 'default'
+
+```shell
+$ simple-scaffold -gh chenasraf/simple-scaffold MyComponent
+```
+
+You can also add this as a script in your `package.json`:
+
+```json
+{
+  "scripts": {
+    "scaffold": "npx simple-scaffold@latest -t scaffolds/component/**/* -o src/components -d '{\"myProp\": \"propName\", \"myVal\": 123}'"
+  }
+}
+```

pages/configuration_files.md

@@ -0,0 +1,155 @@
+If you want to have reusable configurations which are complex and don't fit into command lines
+easily, or just want to manage your templates easier, you can use configuration files to load your
+scaffolding configurations.
+
+## Creating config files
+
+Configuration files should be valid `.js`/`.json` files that contain valid Scaffold configurations.
+
+Each file hold multiple scaffolds. Each scaffold is a key, and its value is the configuration. For
+example:
+
+```json
+{
+  "component": {
+    "templates": ["templates/component"],
+    "output": "src/components"
+  }
+}
+```
+
+The configuration contents are identical to the
+[Node.js configuration structure](https://chenasraf.github.io/simple-scaffold/pages/node.md):
+
+```ts
+interface ScaffoldConfig {
+  name: string
+  templates: string[]
+  output: FileResponse<string>
+  createSubFolder?: boolean
+  data?: Record<string, any>
+  overwrite?: FileResponse<boolean>
+  quiet?: boolean
+  verbose?: LogLevel
+  dryRun?: boolean
+  helpers?: Record<string, Helper>
+  subFolderNameHelper?: DefaultHelpers | string
+  beforeWrite?(
+    content: Buffer,
+    rawContent: Buffer,
+    outputPath: string,
+  ): string | Buffer | undefined | Promise<string | Buffer | undefined>
+}
+```
+
+If you want to supply functions inside the configurations, you must use a `.js` file as JSON does
+not support non-primitives.
+
+A `.js` file is just like a `.json` file, make sure to export the final configuration:
+
+```js
+/** @type {import('simple-scaffold').ScaffoldConfigFile} */
+module.exports = {
+  component: {
+    templates: ["templates/component"],
+    output: "src/components",
+  },
+}
+```
+
+## Using a config file
+
+Once your config is created, you can use it by providing the file name to the `--config` (or `-c`
+for brevity), optionally followed by a colon, then your scaffold config name.
+
+```shell
+simple-scaffold -c <file>[:<template_key>]
+```
+
+For example:
+
+```shell
+simple-scaffold -c scaffold.json:component MyComponentName
+```
+
+If you don't want to supply a template/config name (e.g. `component`), you can omit the colon and
+the name, and it will use the configuration named `default`:
+
+```js
+/** @type {import('simple-scaffold').ScaffoldConfigFile} */
+module.exports = {
+  default: {
+    // ...
+  },
+}
+```
+
+And then:
+
+```shell
+# will use 'default' template
+simple-scaffold -c scaffold.json MyComponentName
+```
+
+## Remote Templates
+
+You can load template groups remotely, similar to how you would pass a config normally.
+
+The main difference is the templates will be hosted on a remote location such as a git server, and
+not locally in your project. This can be done to easily share & reuse templates.
+
+When passing a git URL to `--config`, you will clone that repo and use the files there as template.
+
+The syntax is as follows:
+
+```shell
+simple-scaffold -c <git_url>[#<git_file>][:<template_key>]
+```
+
+For example, to use this repository's example as base:
+
+```shell
+simple-scaffold -c https://github.com/chenasraf/simple-scaffold.git#examples/test-input/scaffold.config.js:component
+```
+
+When the filename is omitted, `/scaffold.config.js` will be used as default.
+
+When the template_key is ommitted, `default` will be used as default.
+
+### GitHub Templates
+
+As a shorter alternative to the above example, you can use `--github` or `-gh` to reference a GitHub
+URL without specifying the whole path.
+
+The syntax is as follows:
+
+```shell
+simple-scaffold -gh <username>/<project_name>[#<git_file>][:<template_key>]
+```
+
+This example is equivalent to the above, just shorter to write:
+
+```shell
+simple-scaffold -c chenasraf/simple-scaffold#examples/test-input/scaffold.config.js:component
+```
+
+## Use In Node.js
+
+You can also start a scaffold from Node.js with a remote file or URL config.
+
+Just use the `Scaffold.fromConfig` function:
+
+```ts
+Scaffold.fromConfig(
+  "scaffold.config.js", // file or HTTPS git URL
+  {
+    // name of the generated component
+    name: "My Component",
+    // key to load from the config
+    key: "component",
+  },
+  {
+    // other config overrides
+  },
+)
+```

pages/migration.md

@@ -0,0 +1,25 @@
+In Simple Scaffold v1.0, the entire codebase was overhauled, yet usage remains mostly the same
+between versions. With these notable exceptions:
+
+- Some of the argument names have changed
+- Template syntax has been improved
+- The command to run Scaffold has been simplified from `new SimpleScaffold(opts).run()` to
+  `SimpleScaffold(opts)`, which now returns a promise that you can await to know when the process
+  has been completed.
+
+## Argument changes
+
+- `locals` has been renamed to `data`. The appropriate command line args have been updated as well
+  to `--data` | `-d`.
+- Additional options have been added to both CLI and Node interfaces. See
+  [Command Line Interface (CLI) usage](https://chenasraf.github.io/simple-scaffold/pages/cli.html)
+  and [Node.js usage](https://chenasraf.github.io/simple-scaffold/pages/node.html) for more
+  information.
+
+## Template syntax changes
+
+Simple Scaffold still uses Handlebars.js to handle template content and file names. However, helpers
+have been added to remove the need for you to pre-process the template data on simple use-cases such
+as case type manipulation (converting to camel case, snake case, etc)
+
+See the readme for the full information on how to use these helpers and which are available.

pages/node.md

@@ -0,0 +1,53 @@
+You can build the scaffold yourself, if you want to create more complex arguments, scaffold groups,
+etc - simply pass a config object to the Scaffold function when you are ready to start.
+
+The config takes similar arguments to the command line. The full type definitions can be found in
+[src/types.ts](https://github.com/chenasraf/simple-scaffold/blob/develop/src/types.ts#L13).
+
+See the full
+[documentation](https://chenasraf.github.io/simple-scaffold/interfaces/ScaffoldConfig.html) for the
+configuration options and their behavior.
+
+```ts
+interface ScaffoldConfig {
+  name: string
+  templates: string[]
+  output: FileResponse<string>
+  createSubFolder?: boolean
+  data?: Record<string, any>
+  overwrite?: FileResponse<boolean>
+  quiet?: boolean
+  verbose?: LogLevel
+  dryRun?: boolean
+  helpers?: Record<string, Helper>
+  subFolderNameHelper?: DefaultHelpers | string
+  beforeWrite?(
+    content: Buffer,
+    rawContent: Buffer,
+    outputPath: string,
+  ): string | Buffer | undefined | Promise<string | Buffer | undefined>
+}
+```
+
+This is an example of loading a complete scaffold via Node.js:
+
+```typescript
+import Scaffold from "simple-scaffold"
+
+const config = {
+  name: "component",
+  templates: [path.join(__dirname, "scaffolds", "component")],
+  output: path.join(__dirname, "src", "components"),
+  createSubFolder: true,
+  subFolderNameHelper: "upperCase"
+  data: {
+    property: "value",
+  },
+  helpers: {
+    twice: (text) => [text, text].join(" ")
+  },
+  beforeWrite: (content, rawContent, outputPath) => content.toString().toUpperCase()
+}
+
+const scaffold = Scaffold(config)
+```

pages/templates.md

@@ -0,0 +1,224 @@
+# Preparing template files
+
+Put your template files anywhere, and fill them with tokens for replacement.
+
+Each template (not file) in the config array is parsed individually, and copied to the output
+directory. If a single template path contains multiple files (e.g. if you use a folder path or a
+glob pattern), the first directory up the tree of that template will become the base inside the
+defined output path for that template, while copying files recursively and maintaining their
+relative structure.
+
+Examples:
+
+> In the following examples, the config `name` is `AppName`, and the config `output` is `src`.
+
+| Input template                | Files in template                                      | Output path(s)                                               |
+| ----------------------------- | ------------------------------------------------------ | ------------------------------------------------------------ |
+| `./templates/{{ name }}.txt`  | `./templates/{{ name }}.txt`                           | `src/AppName.txt`                                            |
+| `./templates/directory`       | `outer/{{name}}.txt`,<br />`outer2/inner/{{name}}.txt` | `src/outer/AppName.txt`,<br />`src/outer2/inner/AppName.txt` |
+| `./templates/others/**/*.txt` | `outer/{{name}}.jpg`,<br />`outer2/inner/{{name}}.txt` | `src/outer2/inner/AppName.txt`                               |
+
+## Variable/token replacement
+
+Scaffolding will replace `{{ varName }}` in both the file name and its contents and put the
+transformed files in the output directory.
+
+The data available for the template parser is the data you pass to the `data` config option (or
+`--data` argument in CLI).
+
+For example, using the following command:
+
+```bash
+npx simple-scaffold@latest \
+  --templates templates/components/{{name}}.jsx \
+  --output src/components \
+  --create-sub-folder true \
+  MyComponent
+```
+
+Will output a file with the path:
+
+```text
+<working_dir>/src/components/MyComponent.jsx
+```
+
+The contents of the file will be transformed in a similar fashion.
+
+Your `data` will be pre-populated with the following:
+
+- `{{Name}}`: PascalCase of the component name
+- `{{name}}`: raw name of the component as you entered it
+
+> Simple-Scaffold uses [Handlebars.js](https://handlebarsjs.com/) for outputting the file contents.
+> Any `data` you add in the config will be available for use with their names wrapped in `{{` and
+> `}}`. Other Handlebars built-ins such as `each`, `if` and `with` are also supported, see
+> [Handlebars.js Language Features](https://handlebarsjs.com/guide/#language-features) for more
+> information.
+
+## Helpers
+
+### Built-in Helpers
+
+Simple-Scaffold provides some built-in text transformation filters usable by Handlebars.
+
+For example, you may use `{{ snakeCase name }}` inside a template file or filename, and it will
+replace `My Name` with `my_name` when producing the final value.
+
+#### Capitalization Helpers
+
+| Helper name  | Example code            | Example output |
+| ------------ | ----------------------- | -------------- |
+| [None]       | `{{ name }}`            | my name        |
+| `camelCase`  | `{{ camelCase name }}`  | myName         |
+| `snakeCase`  | `{{ snakeCase name }}`  | my_name        |
+| `startCase`  | `{{ startCase name }}`  | My Name        |
+| `kebabCase`  | `{{ kebabCase name }}`  | my-name        |
+| `hyphenCase` | `{{ hyphenCase name }}` | my-name        |
+| `pascalCase` | `{{ pascalCase name }}` | MyName         |
+| `upperCase`  | `{{ upperCase name }}`  | MY NAME        |
+| `lowerCase`  | `{{ lowerCase name }}`  | my name        |
+
+#### Date helpers
+
+| Helper name                      | Description                                                      | Example code                                                     | Example output     |
+| -------------------------------- | ---------------------------------------------------------------- | ---------------------------------------------------------------- | ------------------ |
+| `now`                            | Current date with format                                         | `{{ now "yyyy-MM-dd HH:mm" }}`                                   | `2042-01-01 15:00` |
+| `now` (with offset)              | Current date with format, and with offset                        | `{{ now "yyyy-MM-dd HH:mm" -1 "hours" }}`                        | `2042-01-01 14:00` |
+| `date`                           | Custom date with format                                          | `{{ date "2042-01-01T15:00:00Z" "yyyy-MM-dd HH:mm" }}`           | `2042-01-01 15:00` |
+| `date` (with offset)             | Custom date with format, and with offset                         | `{{ date "2042-01-01T15:00:00Z" "yyyy-MM-dd HH:mm" -1 "days" }}` | `2041-31-12 15:00` |
+| `date` (with date from `--data`) | Custom date with format, with data from the `data` config option | `{{ date myCustomDate "yyyy-MM-dd HH:mm" }}`                     | `2042-01-01 12:00` |
+
+Further details:
+
+- We use [`date-fns`](https://date-fns.org/docs/) for parsing/manipulating the dates. If you want
+  more information on the date tokens to use, refer to
+  [their format documentation](https://date-fns.org/docs/format).
+
+- The date helper format takes the following arguments:
+
+  ```typescript
+  (
+    date: string,
+    format: string,
+    offsetAmount?: number,
+    offsetType?: "years" | "months" | "weeks" | "days" | "hours" | "minutes" | "seconds"
+  )
+  ```
+
+- **The now helper** (for current time) takes the same arguments, minus the first one (`date`) as it
+  is implicitly the current date.
+
+### Custom Helpers
+
+You may also add your own custom helpers using the `helpers` options when using the JS API (rather
+than the CLI). The `helpers` option takes an object whose keys are helper names, and values are the
+transformation functions. For example, `upperCase` is implemented like so:
+
+```typescript
+config.helpers = {
+  upperCase: (text) => text.toUpperCase(),
+}
+```
+
+All of the above helpers (built in and custom) will also be available to you when using
+`subFolderNameHelper` (`--sub-folder-name-helper`/`-sh`) as a possible value.
+
+> To see more information on how helpers work and more features, see
+> [Handlebars.js docs](https://handlebarsjs.com/guide/#custom-helpers).
+
+# Examples
+
+## Run
+
+### Command Example
+
+```bash
+simple-scaffold MyComponent \
+    -t project/scaffold/**/* \
+    -o src/components \
+    -d '{"className": "myClassName","author": "Chen Asraf"}'
+    MyComponent
+```
+
+### Equivalent Node Module Example
+
+```typescript
+import Scaffold from "simple-scaffold"
+
+async function main() {
+  await Scaffold({
+    name: "MyComponent",
+    templates: ["project/scaffold/**/*"],
+    output: ["src/components"],
+    data: {
+      className: "myClassName",
+      author: "Chen Asraf",
+    },
+  })
+  console.log("Done.")
+}
+```
+
+## Files
+
+### Input
+
+- Input file path:
+
+  ```text
+  project → scaffold → {{Name}}.js → src → components
+  ```
+
+- Input file contents:
+
+  ```typescript
+  /**
+   * Author: {{ author }}
+   * Date: {{ now "yyyy-MM-dd" }}
+   */
+  import React from 'react'
+
+  export default {{camelCase name}}: React.FC = (props) => {
+    return (
+      <div className="{{className}}">{{camelCase name}} Component</div>
+    )
+  }
+  ```
+
+### Output
+
+- Output file path:
+
+  - With `createSubFolder = false` (default):
+
+    ```text
+    project → src → components → MyComponent.js
+    ```
+
+  - With `createSubFolder = true`:
+
+    ```text
+    project → src → components → MyComponent → MyComponent.js
+    ```
+
+  - With `createSubFolder = true` and `subFolderNameHelper = 'upperCase'`:
+
+    ```text
+    project → src → components → MYCOMPONENT → MyComponent.js
+    ```
+
+- Output file contents:
+
+  ```typescript
+  /**
+   * Author: Chen Asraf
+   * Date: 2077-01-01
+   */
+  import React from 'react'
+
+  export default MyComponent: React.FC = (props) => {
+    return (
+      <div className="myClassName">MyComponent Component</div>
+    )
+  }
+  ```

release.config.js

@@ -0,0 +1,76 @@
+const releaseRules = [
+  { type: "feat", section: "Features", release: "minor" },
+  { type: "docs", section: "Build", release: false },
+  { type: "fix", section: "Bug Fixes", release: "patch" },
+  { type: "refactor", section: "Misc", release: "patch" },
+  { type: "perf", section: "Misc", release: "patch" },
+  { type: "build", section: "Build", release: "patch" },
+  { type: "chore", section: "Misc", release: "patch" },
+  { type: "test", section: "Tests", release: "patch" },
+]
+
+/** @type {import('semantic-release').Options} */
+module.exports = {
+  branches: [
+    "+([0-9])?(.{+([0-9]),x}).x",
+    "master",
+    "next",
+    "next-major",
+    { name: "develop", prerelease: true },
+    { name: "beta", prerelease: true },
+    { name: "alpha", prerelease: true },
+  ],
+  analyzeCommits: {
+    path: "semantic-release-conventional-commits",
+    majorTypes: ["major", "breaking"],
+    minorTypes: ["minor", "feat", "feature"],
+    patchTypes: ["patch", "fix", "bugfix", "refactor", "perf", "revert"],
+  },
+  plugins: [
+    [
+      "@semantic-release/commit-analyzer",
+      {
+        preset: "conventionalcommits",
+        parserOpts: {
+          noteKeywords: ["breaking:", "breaking-fix:", "breaking-feat:"],
+        },
+        releaseRules: releaseRules,
+      },
+    ],
+    [
+      "@semantic-release/release-notes-generator",
+      {
+        preset: "conventionalcommits",
+        parserOpts: {
+          noteKeywords: ["breaking"],
+          types: releaseRules,
+        },
+      },
+    ],
+    [
+      "@semantic-release/changelog",
+      {
+        changelogFile: "CHANGELOG.md",
+        changelogTitle: "# Change Log",
+      },
+    ],
+    [
+      "@semantic-release/npm",
+      {
+        pkgRoot: "dist",
+      },
+    ],
+    [
+      "@semantic-release/git",
+      {
+        assets: ["CHANGELOG.md", "package.json"],
+      },
+    ],
+    [
+      "@semantic-release/github",
+      {
+        assets: ["package.tgz"],
+      },
+    ],
+  ],
+}

scaffold.ts

@@ -1,88 +0,0 @@
-import * as fs from 'fs'
-import * as path from 'path'
-import { IScaffold } from './index'
-
-class SimpleScaffold {
-  private config: IScaffold.IConfig
-  private locals = {} as any
-  public scaffoldName = process.argv[2]
-  private DefaultConfig: IScaffold.IConfig = {
-    templates: [],
-    output: path.resolve(process.cwd()),
-    locals: {
-      Name: this.scaffoldName[0].toUpperCase() + this.scaffoldName.slice(1),
-      name: this.scaffoldName[0].toLowerCase() + this.scaffoldName.slice(1)
-    }
-  }
-
-  constructor(config: IScaffold.IConfig) {
-    if (!this.scaffoldName) {
-      throw new Error('Must provide scaffold name')
-    }
-    this.config = (Object as any).assign({}, this.DefaultConfig, config)
-    this.locals = (Object as any).assign({}, this.DefaultConfig.locals, config.locals)
-    console.info('Config loaded:', this.config)
-    console.info('Locals:', this.locals)
-  }
-
-  private parseLocals(text: string): string {
-    let out = text.toString()
-    const pattern = /{[%]\s*([^%{}]+)\s*[%]}/gi
-    return out.replace(pattern, (match: string, $1: string) => this.locals[$1])
-  }
-
-  private getFileList(pathList: string[]): string[] {
-    let outList: string[] = []
-
-    pathList.forEach((checkPath: string) => {
-      const stat = fs.lstatSync(checkPath)
-      if (stat.isFile()) {
-        console.info('pushing', checkPath)
-        outList.push(checkPath)
-      } else if (stat.isDirectory()) {
-        console.info('going into dir', checkPath)
-        const innerFiles = fs.readdirSync(checkPath).map(p => path.join(checkPath, p))
-        outList = outList.concat(this.getFileList(innerFiles))
-      }
-    })
-
-    return outList
-  }
-
-  private getFileContents(filePath: string): string {
-    return fs.readFileSync(filePath).toString()
-  }
-
-  private getOutputPath(file: string): string {
-    let out
-
-    if (typeof this.config.output === 'function') {
-      out = this.config.output(file)
-    } else {
-      out = this.config.output + `/${this.scaffoldName}/` + path.basename(file)
-    }
-
-    return this.parseLocals(out)
-  }
-
-  private writeFile(filePath: string, fileContents: string): void {
-    if (!fs.existsSync(path.dirname(filePath))) {
-      fs.mkdirSync(path.dirname(filePath))
-    }
-    console.info('Writing file:', filePath)
-    fs.writeFileSync(filePath, fileContents, { encoding: 'utf-8' })
-  }
-
-  public run() {
-    const inputFiles = this.getFileList(this.config.templates)
-    console.info(inputFiles)
-    inputFiles.forEach((file: string) => {
-      const outputPath = this.getOutputPath(file)
-      const contents = this.getFileContents(file)
-      const outputContents = this.parseLocals(contents)
-      this.writeFile(outputPath, outputContents)
-    })
-  }
-}
-
-exports.default = SimpleScaffold

scripts/test.js

@@ -1,12 +0,0 @@
-const Scaffolder = require('../dist/scaffold').default
-
-const templateDir = process.cwd() + '/examples'
-
-const scf = new Scaffolder({
-  templates: [templateDir + '/test-input/Component'],
-  output: templateDir + '/test-output',
-  locals: {
-    property: 'myProp',
-    value: '"value"'
-  }
-}).run()

src/cmd.ts

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+import massarg from "massarg"
+import chalk from "chalk"
+import { LogLevel, ScaffoldCmdConfig } from "./types"
+import { Scaffold } from "./scaffold"
+import path from "path"
+import fs from "fs/promises"
+import { parseAppendData, parseConfig } from "./utils"
+
+export async function parseCliArgs(args = process.argv.slice(2)) {
+  const pkg = JSON.parse((await fs.readFile(path.join(__dirname, "package.json"))).toString())
+  const isConfig = args.includes("--config") || args.includes("-c") || args.includes("--github") || args.includes("-gh")
+
+  return (
+    massarg<ScaffoldCmdConfig>()
+      .main(async (config) => {
+        const _config = await parseConfig(config)
+        return Scaffold(_config)
+      })
+      .option({
+        name: "name",
+        aliases: ["n"],
+        description:
+          "Name to be passed to the generated files. {{name}} and {{Name}} inside contents and file names will be replaced accordingly.",
+        isDefault: true,
+        required: true,
+      })
+      .option({
+        name: "config",
+        aliases: ["c"],
+        description:
+          "Filename or https git URL to load config from instead of passing arguments to CLI or using a Node.js script. See examples for syntax.",
+      })
+      .option({
+        name: "github",
+        aliases: ["gh"],
+        description:
+          "GitHub path to load config from instead of passing arguments to CLI or using a Node.js script. See examples for syntax.",
+      })
+      .option({
+        name: "key",
+        aliases: ["k"],
+        description:
+          "Key to load inside the config file. This overwrites the config key provided after the colon in --config (e.g. --config scaffold.cmd.js:component)",
+      })
+      .option({
+        name: "output",
+        aliases: ["o"],
+        description: `Path to output to. If --create-sub-folder is enabled, the subfolder will be created inside this path. ${chalk.reset`${chalk.white`(default: current dir)`}`}`,
+        required: !isConfig,
+      })
+      .option({
+        name: "templates",
+        aliases: ["t"],
+        array: true,
+        description:
+          "Template files to use as input. You may provide multiple files, each of which can be a relative or absolute path, " +
+          "or a glob pattern for multiple file matching easily.",
+        required: !isConfig,
+      })
+      .option({
+        name: "overwrite",
+        aliases: ["w"],
+        boolean: true,
+        defaultValue: false,
+        description: "Enable to override output files, even if they already exist.",
+      })
+      .option({
+        name: "data",
+        aliases: ["d"],
+        description: "Add custom data to the templates. By default, only your app name is included.",
+        parse: (v) => JSON.parse(v),
+      })
+      .option({
+        name: "append-data",
+        aliases: ["D"],
+        description:
+          "Append additional custom data to the templates, which will overwrite --data, using an alternate syntax, which is easier to use with CLI: -D key1=string -D key2:=raw",
+        parse: parseAppendData,
+      })
+      .option({
+        name: "create-sub-folder",
+        aliases: ["s"],
+        boolean: true,
+        defaultValue: false,
+        description: "Create subfolder with the input name",
+      })
+      .option({
+        name: "sub-folder-name-helper",
+        aliases: ["sh"],
+        description: "Default helper to apply to subfolder name when using `--create-sub-folder true`.",
+      })
+      .option({
+        name: "quiet",
+        aliases: ["q"],
+        boolean: true,
+        defaultValue: false,
+        description: "Suppress output logs (Same as --verbose 0)",
+      })
+      .option({
+        name: "verbose",
+        aliases: ["v"],
+        defaultValue: LogLevel.Info,
+        description:
+          "Determine amount of logs to display. The values are: " +
+          `${chalk.bold`0 (none) | 1 (debug) | 2 (info) | 3 (warn) | 4 (error)`}. ` +
+          "The provided level will display messages of the same level or higher.",
+        parse: Number,
+      })
+      .option({
+        name: "dry-run",
+        aliases: ["dr"],
+        boolean: true,
+        defaultValue: false,
+        description:
+          "Don't emit files. This is good for testing your scaffolds and making sure they " +
+          "don't fail, without having to write actual file contents or create directories.",
+      })
+      // .example({
+      //   input: `yarn cmd -t examples/test-input/Component -o examples/test-output -d '{"property":"myProp","value":"10"}'`,
+      //   description: "Usage",
+      //   output: "",
+      // })
+      .example({
+        description: "Usage with config file",
+        input: "simple-scaffold -c scaffold.cmd.js --key component",
+      })
+      .example({
+        description: "Usage with GitHub config file",
+        input: "simple-scaffold -gh chenasraf/simple-scaffold --key component",
+      })
+      .example({
+        description: "Usage with https git URL (for non-GitHub)",
+        input: "simple-scaffold -c https://example.com/user/template.git#scaffold.cmd.js --key component",
+      })
+      .example({
+        description: "Full syntax with config path and template key (applicable to all above methods)",
+        input: "simple-scaffold -c scaffold.cmd.js:component MyComponent",
+      })
+      .example({
+        description: "Excluded template key, assumes 'default' key",
+        input: "simple-scaffold -c scaffold.cmd.js MyComponent",
+      })
+      .example({
+        description: "Shortest syntax for GitHub, assumes file 'scaffold.cmd.js' and template key 'default'",
+        input: "simple-scaffold -gh chenasraf/simple-scaffold MyComponent",
+      })
+      .help({
+        binName: "simple-scaffold",
+        useGlobalColumns: true,
+        usageExample: "[options]",
+        printWidth: 100,
+        header: [`Create structured files based on templates.`].join("\n"),
+        footer: [
+          `Version:  ${pkg.version}`,
+          `Copyright © Chen Asraf 2017-${new Date().getFullYear()}`,
+          ``,
+          `Documentation: ${chalk.underline`https://chenasraf.github.io/simple-scaffold`}`,
+          `NPM: ${chalk.underline`https://npmjs.com/package/simple-scaffold`}`,
+          `GitHub: ${chalk.underline`https://github.com/chenasraf/simple-scaffold`}`,
+        ].join("\n"),
+      })
+      .parse(args)
+  )
+}
+
+parseCliArgs()

src/docs.css

@@ -0,0 +1,55 @@
+.tsd-typography table {
+  border-collapse: collapse;
+  width: 100%;
+}
+
+.tsd-typography table td,
+.tsd-typography table th {
+  vertical-align: top;
+  border: 1px solid var(--color-accent);
+  padding: 6px;
+}
+.tsd-typography h1 + pre,
+.tsd-typography h2 + pre,
+.tsd-typography h3 + pre,
+.tsd-typography h4 + pre,
+.tsd-typography h5 + pre,
+.tsd-typography h6 + pre,
+/*  */
+.tsd-typography h1 + table,
+.tsd-typography h2 + table,
+.tsd-typography h3 + table,
+.tsd-typography h4 + table,
+.tsd-typography h5 + table,
+.tsd-typography h6 + table {
+  margin-top: 1em;
+}
+
+.tsd-typography pre + a + h1,
+.tsd-typography pre + a + h2,
+.tsd-typography pre + a + h3,
+.tsd-typography pre + a + h4,
+.tsd-typography pre + a + h5,
+.tsd-typography pre + a + h6,
+/*  */
+.tsd-typography table + a + h1,
+.tsd-typography table + a + h2,
+.tsd-typography table + a + h3,
+.tsd-typography table + a + h4,
+.tsd-typography table + a + h5,
+.tsd-typography table + a + h6 {
+  margin-top: 2em;
+}
+
+.tsd-index-accordion[data-key*="Configuration."] ul.tsd-nested-navigation,
+.tsd-index-accordion[data-key*="Configuration."] .tsd-accordion-summary > svg,
+.tsd-index-accordion[data-key="Changelog"] ul.tsd-nested-navigation,
+.tsd-index-accordion[data-key="Changelog"] .tsd-accordion-summary > svg,
+.tsd-index-accordion[data-key="Configuration"] li:nth-child(n + 6) {
+  display: none;
+}
+
+.tsd-index-accordion[data-key*="Configuration."],
+.tsd-index-accordion[data-key="Changelog"] {
+  margin-left: 0;
+}

src/index.ts

@@ -0,0 +1,4 @@
+export * from "./scaffold"
+export * from "./types"
+import Scaffold from "./scaffold"
+export default Scaffold

src/scaffold.ts

@@ -0,0 +1,177 @@
+/**
+ * @module
+ * Simple Scaffold
+ *
+ * See [readme](README.md)
+ */
+import path from "path"
+
+import {
+  createDirIfNotExists,
+  getOptionValueForFile,
+  handleErr,
+  log,
+  pascalCase,
+  isDir,
+  removeGlob,
+  makeRelativePath,
+  registerHelpers,
+  getTemplateGlobInfo,
+  getFileList,
+  getBasePath,
+  copyFileTransformed,
+  getTemplateFileInfo,
+  logInitStep,
+  logInputFile,
+  parseConfig,
+} from "./utils"
+import { LogLevel, ScaffoldCmdConfig, ScaffoldConfig } from "./types"
+import { OptionsBase } from "massarg/types"
+
+/**
+ * Create a scaffold using given `options`.
+ *
+ * #### Create files
+ * To create a file structure to output, use any directory and file structure you would like.
+ * Inside folder names, file names or file contents, you may place `{{ var }}` where `var` is either
+ * `name` which is the scaffold name you provided or one of the keys you provided in the `data` option.
+ *
+ * The contents and names will be replaced with the transformed values so you can use your original structure as a
+ * boilerplate for other projects, components, modules, or even single files.
+ *
+ * The files will maintain their structure, starting from the directory containing the template (or the template itself
+ * if it is already a directory), and will output from that directory into the directory defined by `config.output`.
+ *
+ * #### Helpers
+ * Helpers are functions you can use to transform your `{{ var }}` contents into other values without having to
+ * pre-define the data and use a duplicated key.
+ *
+ * Any functions you provide in `helpers` option will also be available to you to make custom formatting as you see fit
+ * (for example, formatting a date)
+ *
+ * For available default values, see {@link DefaultHelpers}.
+ *
+ * @param {ScaffoldConfig} config The main configuration object
+ * @return {Promise<void>} A promise that resolves when the scaffold is complete
+ *
+ * @see {@link DefaultHelpers}
+ * @see {@link CaseHelpers}
+ * @see {@link DateHelpers}
+ *
+ * @category Main
+ */
+export async function Scaffold(config: ScaffoldConfig): Promise<void> {
+  config.output ??= process.cwd()
+
+  registerHelpers(config)
+  try {
+    config.data = { name: config.name, Name: pascalCase(config.name), ...config.data }
+    logInitStep(config)
+    for (let _template of config.templates) {
+      try {
+        const { nonGlobTemplate, origTemplate, isDirOrGlob, isGlob, template } = await getTemplateGlobInfo(
+          config,
+          _template,
+        )
+        const files = await getFileList(config, template)
+        for (const inputFilePath of files) {
+          if (await isDir(inputFilePath)) {
+            continue
+          }
+          const relPath = makeRelativePath(path.dirname(removeGlob(inputFilePath).replace(nonGlobTemplate, "")))
+          const basePath = getBasePath(relPath)
+          logInputFile(config, {
+            origTemplate,
+            relPath,
+            template,
+            inputFilePath,
+            nonGlobTemplate,
+            basePath,
+            isDirOrGlob,
+            isGlob,
+          })
+          await handleTemplateFile(config, {
+            templatePath: inputFilePath,
+            basePath,
+          })
+        }
+      } catch (e: any) {
+        handleErr(e)
+      }
+    }
+  } catch (e: any) {
+    log(config, LogLevel.Error, e)
+    throw e
+  }
+}
+
+/**
+ * Create a scaffold based on a config file or URL.
+ *
+ * @param {string} pathOrUrl The path or URL to the config file
+ * @param {Record<string, string>} config Information needed before loading the config
+ * @param {Partial<Omit<ScaffoldConfig, 'name'>>} overrides Any overrides to the loaded config
+ *
+ * @see {@link Scaffold}
+ * @category Main
+ * @return {Promise<void>} A promise that resolves when the scaffold is complete
+ */
+Scaffold.fromConfig = async function (
+  pathOrUrl: string,
+  config: Pick<ScaffoldCmdConfig, "name" | "key">,
+  overrides?: Partial<Omit<ScaffoldConfig, "name">>,
+): Promise<void> {
+  const _cmdConfig: ScaffoldCmdConfig & OptionsBase = {
+    dryRun: false,
+    output: process.cwd(),
+    verbose: LogLevel.Info,
+    overwrite: false,
+    templates: [],
+    createSubFolder: false,
+    quiet: false,
+    help: false,
+    extras: [],
+    config: pathOrUrl,
+    ...config,
+  }
+  const _config = await parseConfig(_cmdConfig)
+  return Scaffold({ ..._config, ...overrides })
+}
+
+async function handleTemplateFile(
+  config: ScaffoldConfig,
+  { templatePath, basePath }: { templatePath: string; basePath: string },
+): Promise<void> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const { inputPath, outputPathOpt, outputDir, outputPath, exists } = await getTemplateFileInfo(config, {
+        templatePath,
+        basePath,
+      })
+      const overwrite = getOptionValueForFile(config, inputPath, config.overwrite ?? false)
+
+      log(
+        config,
+        LogLevel.Debug,
+        `\nParsing ${templatePath}`,
+        `\nBase path: ${basePath}`,
+        `\nFull input path: ${inputPath}`,
+        `\nOutput Path Opt: ${outputPathOpt}`,
+        `\nFull output dir: ${outputDir}`,
+        `\nFull output path: ${outputPath}`,
+        `\n`,
+      )
+
+      await createDirIfNotExists(path.dirname(outputPath), config)
+
+      log(config, LogLevel.Info, `Writing to ${outputPath}`)
+      await copyFileTransformed(config, { exists, overwrite, outputPath, inputPath })
+      resolve()
+    } catch (e: any) {
+      handleErr(e)
+      reject(e)
+    }
+  })
+}
+
+export default Scaffold

src/types.ts

@@ -0,0 +1,354 @@
+import { HelperDelegate } from "handlebars/runtime"
+
+/**
+ * The config object for defining a scaffolding group.
+ *
+ * @see {@link https://chenasraf.github.io/simple-scaffold/pages/node.html | Node.js usage}
+ * @see {@link https://chenasraf.github.io/simple-scaffold/pages/cli.html | CLI usage}
+ * @see {@link DefaultHelpers}
+ * @see {@link CaseHelpers}
+ * @see {@link DateHelpers}
+ *
+ * @category Config
+ */
+export interface ScaffoldConfig {
+  /**
+   * Name to be passed to the generated files. `{{name}}` and `{{Name}}` inside contents and file names will be replaced
+   * accordingly.
+   */
+  name: string
+
+  /**
+   * Template files to use as input. You may provide multiple files, each of which can be a relative or absolute path,
+   * or a glob pattern for multiple file matching easily.
+   *
+   * @default Current working directory
+   */
+  templates: string[]
+
+  /**
+   * Path to output to. If `createSubFolder` is `true`, the subfolder will be created inside this path.
+   *
+   * May also be a {@link FileResponseHandler} which returns a new output path to override the default one.
+   *
+   * @see {@link FileResponse}
+   * @see {@link FileResponseHandler}
+   */
+  output: FileResponse<string>
+
+  /**
+   * Whether to create subfolder with the input name.
+   *
+   * When `true`, you may also use {@link subFolderNameHelper} to determine a pre-process helper on
+   * the directory name.
+   *
+   * @default `false`
+   */
+  createSubFolder?: boolean
+
+  /**
+   * Add custom data to the templates. By default, only your app name is included as `{{name}}` and `{{Name}}`.
+   *
+   * This can be any object that will be usable by Handlebars.
+   */
+  data?: Record<string, any>
+
+  /**
+   * Enable to override output files, even if they already exist.
+   *
+   * You may supply a function to this option, which can take the arguments `(fullPath, baseDir, baseName)` and returns
+   * a string, to return a dynamic path for each file.
+   *
+   * May also be a {@link FileResponseHandler} which returns a boolean value per file.
+   *
+   * @see {@link FileResponse}
+   * @see {@link FileResponseHandler}
+   *
+   * @default `false`
+   */
+  overwrite?: FileResponse<boolean>
+
+  /**
+   * Suppress output logs (Same as `verbose: 0` or `verbose: LogLevel.None`)
+   *  @see {@link verbose}
+   */
+  quiet?: boolean
+
+  /**
+   * Determine amount of logs to display.
+   *
+   * The values are: `0 (none) | 1 (debug) | 2 (info) | 3 (warn) | 4 (error)`. The provided level will display messages
+   * of the same level or higher.
+   *
+   * @see {@link LogLevel}
+   *
+   * @default `2 (info)`
+   */
+  verbose?: LogLevel
+
+  /**
+   * Don't emit files. This is good for testing your scaffolds and making sure they don't fail, without having to write
+   * actual file contents or create directories.
+   *
+   * @default `false`
+   */
+  dryRun?: boolean
+
+  /**
+   * Additional helpers to add to the template parser. Provide an object whose keys are the name of the function to add,
+   * and the value is the helper function itself. The signature of helpers is as follows:
+   * ```typescript
+   * (text: string, ...args: any[]) => string
+   * ```
+   *
+   * A full example might be:
+   *
+   * ```typescript
+   * Scaffold({
+   *   //...
+   *   helpers: {
+   *     upperKebabCase: (text) => kebabCase(text).toUpperCase()
+   *   }
+   * })
+   * ```
+   *
+   * Which will allow:
+   *
+   * ```
+   * {{ upperKebabCase "my value" }}
+   * ```
+   *
+   * To transform to:
+   *
+   * ```
+   * MY-VALUE
+   * ```
+   *
+   * See {@link DefaultHelpers} for a list of all the built-in available helpers.
+   *
+   * Simple Scaffold uses Handlebars.js, so all the syntax from there is supported. See
+   * [their docs](https://handlebarsjs.com/guide/#custom-helpers) for more information.
+   *
+   * @see {@link DefaultHelpers}
+   * @see {@link CaseHelpers}
+   * @see {@link DateHelpers}
+   * @see {@link https://chenasraf.github.io/simple-scaffold/pages/templates.html | Templates}
+   * */
+  helpers?: Record<string, Helper>
+
+  /**
+   * Default transformer to apply to subfolder name when using `createSubFolder: true`. Can be one of the default
+   * capitalization helpers, or a custom one you provide to `helpers`. Defaults to `undefined`, which means no
+   * transformation is done.
+   *
+   * @see {@link createSubFolder}
+   * @see {@link CaseHelpers}
+   * @see {@link DefaultHelpers}
+   */
+  subFolderNameHelper?: DefaultHelpers | string
+
+  /**
+   * This callback runs right before content is being written to the disk. If you supply this function, you may return
+   * a string that represents the final content of your file, you may process the content as you see fit. For example,
+   * you may run formatters on a file, fix output in edge-cases not supported by helpers or data, etc.
+   *
+   * If the return value of this function is `undefined`, the original content will be used.
+   *
+   * @param content The original template after token replacement
+   * @param rawContent The original template before token replacement
+   * @param outputPath The final output path of the processed file
+   *
+   * @returns {Promise<String | Buffer | undefined> | String | Buffer | undefined} The final output of the file
+   * contents-only, after further modifications - or `undefined` to use the original content (i.e. `content.toString()`)
+   */
+  beforeWrite?(
+    content: Buffer,
+    rawContent: Buffer,
+    outputPath: string,
+  ): string | Buffer | undefined | Promise<string | Buffer | undefined>
+}
+
+/**
+ * The names of the available helper functions that relate to text capitalization.
+ *
+ * These are available for `subfolderNameHelper`.
+ *
+ * | Helper name  | Example code            | Example output |
+ * | ------------ | ----------------------- | -------------- |
+ * | [None]       | `{{ name }}`            | my name        |
+ * | `camelCase`  | `{{ camelCase name }}`  | myName         |
+ * | `snakeCase`  | `{{ snakeCase name }}`  | my_name        |
+ * | `startCase`  | `{{ startCase name }}`  | My Name        |
+ * | `kebabCase`  | `{{ kebabCase name }}`  | my-name        |
+ * | `hyphenCase` | `{{ hyphenCase name }}` | my-name        |
+ * | `pascalCase` | `{{ pascalCase name }}` | MyName         |
+ * | `upperCase`  | `{{ upperCase name }}`  | MY NAME        |
+ * | `lowerCase`  | `{{ lowerCase name }}`  | my name        |
+ *
+ * @see {@link DefaultHelpers}
+ * @see {@link DateHelpers}
+ * @see {@link ScaffoldConfig}
+ * @see {@link ScaffoldConfig.subFolderNameHelper}
+ *
+ * @category Helpers
+ */
+export type CaseHelpers =
+  | "camelCase"
+  | "hyphenCase"
+  | "kebabCase"
+  | "lowerCase"
+  | "pascalCase"
+  | "snakeCase"
+  | "startCase"
+  | "upperCase"
+
+/**
+ * The names of the available helper functions that relate to dates.
+ *
+ * | Helper name                      | Description                                                      | Example code                                                     | Example output     |
+ * | -------------------------------- | ---------------------------------------------------------------- | ---------------------------------------------------------------- | ------------------ |
+ * | `now`                            | Current date with format                                         | `{{ now "yyyy-MM-dd HH:mm" }}`                                   | `2042-01-01 15:00` |
+ * | `now` (with offset)              | Current date with format, and with offset                        | `{{ now "yyyy-MM-dd HH:mm" -1 "hours" }}`                        | `2042-01-01 14:00` |
+ * | `date`                           | Custom date with format                                          | `{{ date "2042-01-01T15:00:00Z" "yyyy-MM-dd HH:mm" }}`           | `2042-01-01 15:00` |
+ * | `date` (with offset)             | Custom date with format, and with offset                         | `{{ date "2042-01-01T15:00:00Z" "yyyy-MM-dd HH:mm" -1 "days" }}` | `2041-31-12 15:00` |
+ * | `date` (with date from `--data`) | Custom date with format, with data from the `data` config option | `{{ date myCustomDate "yyyy-MM-dd HH:mm" }}`                     | `2042-01-01 12:00` |
+ *
+ * Further details:
+ *
+ * - We use [`date-fns`](https://date-fns.org/docs/) for parsing/manipulating the dates. If you want
+ *   more information on the date tokens to use, refer to
+ *   [their format documentation](https://date-fns.org/docs/format).
+ *
+ * - The date helper format takes the following arguments:
+ *
+ *   ```typescript
+ *   (
+ *     date: string,
+ *     format: string,
+ *     offsetAmount?: number,
+ *     offsetType?: "years" | "months" | "weeks" | "days" | "hours" | "minutes" | "seconds"
+ *   )
+ *   ```
+ *
+ * - **The now helper** (for current time) takes the same arguments, minus the first one (`date`) as it is implicitly
+ *   the current date.
+ *
+ * @see {@link DefaultHelpers}
+ * @see {@link CaseHelpers}
+ * @see {@link ScaffoldConfig}
+ *
+ * @category Helpers
+ */
+export type DateHelpers = "date" | "now"
+
+/**
+ * The names of all the available helper functions in templates.
+ * Simple-Scaffold provides some built-in text transformation filters usable by Handlebars.js.
+ *
+ * For example, you may use `{{ snakeCase name }}` inside a template file or filename, and it will
+ * replace `My Name` with `my_name` when producing the final value.
+ *
+ * @see {@link CaseHelpers}
+ * @see {@link DateHelpers}
+ * @see {@link ScaffoldConfig}
+ *
+ * @category Helpers
+ */
+export type DefaultHelpers = CaseHelpers | DateHelpers
+
+/**
+ * Helper function, see https://handlebarsjs.com/guide/#custom-helpers
+ *
+ * @category Helpers
+ */
+export type Helper = HelperDelegate
+
+/**
+ * The amount of information to log when generating scaffold.
+ * When not `None`, the selected level will be the lowest level included.
+ *
+ * For example, level `Info` (2) will include `Info`, `Warning` and `Error`, but not `Debug`; and `Warning` will only
+ * show `Warning` and `Error`.
+ *
+ * @default `2 (info)`
+ *
+ * @category Logging
+ */
+export enum LogLevel {
+  /** Silent output */
+  None = 0,
+  /** Debugging information. Very verbose and only recommended for troubleshooting. */
+  Debug = 1,
+  /**
+   * The regular level of logging. Major actions are logged to show the scaffold progress.
+   *
+   * @default
+   */
+  Info = 2,
+  /** Warnings such as when file fails to replace token values properly in template. */
+  Warning = 3,
+  /** Errors, such as missing files, bad replacement token syntax, or un-writable directories. */
+  Error = 4,
+}
+
+/**
+ * A function that takes path information about file, and returns a value of type `T`
+ *
+ * @template T The return type for the function
+ * @param {string} fullPath The full path of the current file
+ * @param {string} basedir The directory containing the current file
+ * @param {string} basename The name of the file
+ *
+ * @returns {T} A return value
+ *
+ * @category Config
+ */
+export type FileResponseHandler<T> = (fullPath: string, basedir: string, basename: string) => T
+
+/**
+ * Represents a response for file path information.
+ * Can either be:
+ *
+ * 1. `T` - static value
+ * 2. A function with the following signature which returns `T`:
+ *    ```typescript
+ *    (fullPath: string, basedir: string, basename: string) => T
+ *    ```
+ *
+ * @typedef T The return type
+ *
+ * @see {@link FileResponseHandler}
+ *
+ * @category Config
+ * */
+export type FileResponse<T> = T | FileResponseHandler<T>
+
+/** @internal */
+export interface ScaffoldCmdConfig {
+  name: string
+  templates: string[]
+  output: string
+  createSubFolder: boolean
+  data?: Record<string, string>
+  appendData?: Record<string, string>
+  overwrite: boolean
+  quiet: boolean
+  verbose: LogLevel
+  dryRun: boolean
+  config?: string
+  key?: string
+  github?: string
+}
+
+/**
+ * A mapping of scaffold template keys to their configurations.
+ *
+ * Each configuration is a {@link ScaffoldConfig} object.
+ *
+ * The key is the name of the template, and the value is the configuration for that template.
+ *
+ * When no template key is provided to the scaffold command, the "default" template is used.
+ *
+ * @see {@link ScaffoldConfig}
+ */
+export type ScaffoldConfigFile = Record<string, ScaffoldConfig>

src/utils.ts

@@ -0,0 +1,508 @@
+import path from "path"
+import { F_OK } from "constants"
+import {
+  DefaultHelpers,
+  FileResponse,
+  FileResponseHandler,
+  Helper,
+  LogLevel,
+  ScaffoldCmdConfig,
+  ScaffoldConfig,
+  ScaffoldConfigFile,
+} from "./types"
+import camelCase from "lodash/camelCase"
+import snakeCase from "lodash/snakeCase"
+import kebabCase from "lodash/kebabCase"
+import startCase from "lodash/startCase"
+import Handlebars from "handlebars"
+import { promises as fsPromises } from "fs"
+import chalk from "chalk"
+const { stat, access, mkdir } = fsPromises
+import dtAdd from "date-fns/add"
+import dtFormat from "date-fns/format"
+import dtParseISO from "date-fns/parseISO"
+import { glob, hasMagic } from "glob"
+import { OptionsBase } from "massarg/types"
+import { spawn } from "node:child_process"
+import os from "node:os"
+
+const dateFns = {
+  add: dtAdd,
+  format: dtFormat,
+  parseISO: dtParseISO,
+}
+
+const { readFile, writeFile } = fsPromises
+
+export const defaultHelpers: Record<DefaultHelpers, Helper> = {
+  camelCase,
+  snakeCase,
+  startCase,
+  kebabCase,
+  hyphenCase: kebabCase,
+  pascalCase,
+  lowerCase: (text) => text.toLowerCase(),
+  upperCase: (text) => text.toUpperCase(),
+  now: nowHelper,
+  date: dateHelper,
+}
+
+export function _dateHelper(date: Date, formatString: string): string
+export function _dateHelper(
+  date: Date,
+  formatString: string,
+  durationDifference: number,
+  durationType: keyof Duration,
+): string
+export function _dateHelper(
+  date: Date,
+  formatString: string,
+  durationDifference?: number,
+  durationType?: keyof Duration,
+): string {
+  if (durationType && durationDifference !== undefined) {
+    return dateFns.format(dateFns.add(date, { [durationType]: durationDifference }), formatString)
+  }
+  return dateFns.format(date, formatString)
+}
+
+export function nowHelper(formatString: string): string
+export function nowHelper(formatString: string, durationDifference: number, durationType: keyof Duration): string
+export function nowHelper(formatString: string, durationDifference?: number, durationType?: keyof Duration): string {
+  return _dateHelper(new Date(), formatString, durationDifference!, durationType!)
+}
+
+export function dateHelper(date: string, formatString: string): string
+export function dateHelper(
+  date: string,
+  formatString: string,
+  durationDifference: number,
+  durationType: keyof Duration,
+): string
+
+export function dateHelper(
+  date: string,
+  formatString: string,
+  durationDifference?: number,
+  durationType?: keyof Duration,
+): string {
+  return _dateHelper(dateFns.parseISO(date), formatString, durationDifference!, durationType!)
+}
+
+export function registerHelpers(config: ScaffoldConfig): void {
+  const _helpers = { ...defaultHelpers, ...config.helpers }
+  for (const helperName in _helpers) {
+    log(config, LogLevel.Debug, `Registering helper: ${helperName}`)
+    Handlebars.registerHelper(helperName, _helpers[helperName as keyof typeof _helpers])
+  }
+}
+
+export function handleErr(err: NodeJS.ErrnoException | null): void {
+  if (err) throw err
+}
+
+/** @internal */
+export type LogConfig = Pick<ScaffoldConfig, "quiet" | "verbose">
+
+export function log(config: LogConfig, level: LogLevel, ...obj: any[]): void {
+  if (config.quiet || config.verbose === LogLevel.None || level < (config.verbose ?? LogLevel.Info)) {
+    return
+  }
+
+  const levelColor: Record<LogLevel, keyof typeof chalk> = {
+    [LogLevel.None]: "reset",
+    [LogLevel.Debug]: "blue",
+    [LogLevel.Info]: "dim",
+    [LogLevel.Warning]: "yellow",
+    [LogLevel.Error]: "red",
+  }
+
+  const chalkFn: any = chalk[levelColor[level]]
+  const key: "log" | "warn" | "error" = level === LogLevel.Error ? "error" : level === LogLevel.Warning ? "warn" : "log"
+  const logFn: any = console[key]
+  logFn(
+    ...obj.map((i) =>
+      i instanceof Error
+        ? chalkFn(i, JSON.stringify(i, undefined, 1), i.stack)
+        : typeof i === "object"
+        ? chalkFn(JSON.stringify(i, undefined, 1))
+        : chalkFn(i),
+    ),
+  )
+}
+
+export async function createDirIfNotExists(dir: string, config: ScaffoldConfig): Promise<void> {
+  const parentDir = path.dirname(dir)
+
+  if (!(await pathExists(parentDir))) {
+    await createDirIfNotExists(parentDir, config)
+  }
+
+  if (!(await pathExists(dir))) {
+    try {
+      log(config, LogLevel.Debug, `Creating dir ${dir}`)
+      await mkdir(dir)
+      return
+    } catch (e: any) {
+      if (e.code !== "EEXIST") {
+        throw e
+      }
+      return
+    }
+  }
+}
+
+export function getOptionValueForFile<T>(
+  config: ScaffoldConfig,
+  filePath: string,
+  fn: FileResponse<T>,
+  defaultValue?: T,
+): T {
+  if (typeof fn !== "function") {
+    return defaultValue ?? (fn as T)
+  }
+  return (fn as FileResponseHandler<T>)(
+    filePath,
+    path.dirname(handlebarsParse(config, filePath, { isPath: true }).toString()),
+    path.basename(handlebarsParse(config, filePath, { isPath: true }).toString()),
+  )
+}
+
+export function handlebarsParse(
+  config: ScaffoldConfig,
+  templateBuffer: Buffer | string,
+  { isPath = false }: { isPath?: boolean } = {},
+): Buffer {
+  const { data } = config
+  try {
+    let str = templateBuffer.toString()
+    if (isPath) {
+      str = str.replace(/\\/g, "/")
+    }
+    const parser = Handlebars.compile(str, { noEscape: true })
+    let outputContents = parser(data)
+    if (isPath && path.sep !== "/") {
+      outputContents = outputContents.replace(/\//g, "\\")
+    }
+    return Buffer.from(outputContents)
+  } catch (e) {
+    log(config, LogLevel.Debug, e)
+    log(config, LogLevel.Warning, "Couldn't parse file with handlebars, returning original content")
+    return Buffer.from(templateBuffer)
+  }
+}
+
+export async function pathExists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath, F_OK)
+    return true
+  } catch (e: any) {
+    if (e.code === "ENOENT") {
+      return false
+    }
+    throw e
+  }
+}
+
+export function pascalCase(s: string): string {
+  return startCase(s).replace(/\s+/g, "")
+}
+
+export async function isDir(path: string): Promise<boolean> {
+  const tplStat = await stat(path)
+  return tplStat.isDirectory()
+}
+
+export function removeGlob(template: string): string {
+  return template.replace(/\*/g, "").replace(/(\/\/|\\\\)/g, path.sep)
+}
+
+export function makeRelativePath(str: string): string {
+  return str.startsWith(path.sep) ? str.slice(1) : str
+}
+
+export function getBasePath(relPath: string): string {
+  return path
+    .resolve(process.cwd(), relPath)
+    .replace(process.cwd() + path.sep, "")
+    .replace(process.cwd(), "")
+}
+
+export async function getFileList(config: ScaffoldConfig, template: string): Promise<string[]> {
+  return (
+    await glob(template, {
+      dot: true,
+      nodir: true,
+      // debug: config.verbose === LogLevel.Debug,
+    })
+  ).map((f) => f.replace(/\//g, path.sep))
+}
+
+export interface GlobInfo {
+  nonGlobTemplate: string
+  origTemplate: string
+  isDirOrGlob: boolean
+  isGlob: boolean
+  template: string
+}
+
+export async function getTemplateGlobInfo(config: ScaffoldConfig, template: string): Promise<GlobInfo> {
+  const isGlob = hasMagic(template)
+  log(config, LogLevel.Debug, "before isDir", "isGlob:", isGlob, template)
+  let _template = template
+  let nonGlobTemplate = isGlob ? removeGlob(template) : template
+  nonGlobTemplate = path.normalize(nonGlobTemplate)
+  const isDirOrGlob = isGlob ? true : await isDir(template)
+  log(config, LogLevel.Debug, "after isDir", isDirOrGlob)
+  const _shouldAddGlob = !isGlob && isDirOrGlob
+  const origTemplate = template
+  if (_shouldAddGlob) {
+    _template = path.join(template, "**", "*")
+  }
+  return { nonGlobTemplate, origTemplate, isDirOrGlob, isGlob, template: _template }
+}
+
+export interface OutputFileInfo {
+  inputPath: string
+  outputPathOpt: string
+  outputDir: string
+  outputPath: string
+  exists: boolean
+}
+
+export async function getTemplateFileInfo(
+  config: ScaffoldConfig,
+  { templatePath, basePath }: { templatePath: string; basePath: string },
+): Promise<OutputFileInfo> {
+  const inputPath = path.resolve(process.cwd(), templatePath)
+  const outputPathOpt = getOptionValueForFile(config, inputPath, config.output)
+  const outputDir = getOutputDir(config, outputPathOpt, basePath)
+  const outputPath = handlebarsParse(config, path.join(outputDir, path.basename(inputPath)), {
+    isPath: true,
+  }).toString()
+  const exists = await pathExists(outputPath)
+  return { inputPath, outputPathOpt, outputDir, outputPath, exists }
+}
+
+export async function copyFileTransformed(
+  config: ScaffoldConfig,
+  {
+    exists,
+    overwrite,
+    outputPath,
+    inputPath,
+  }: {
+    exists: boolean
+    overwrite: boolean
+    outputPath: string
+    inputPath: string
+  },
+): Promise<void> {
+  if (!exists || overwrite) {
+    if (exists && overwrite) {
+      log(config, LogLevel.Info, `File ${outputPath} exists, overwriting`)
+    }
+    const templateBuffer = await readFile(inputPath)
+    const unprocessedOutputContents = handlebarsParse(config, templateBuffer)
+    const finalOutputContents =
+      (await config.beforeWrite?.(unprocessedOutputContents, templateBuffer, outputPath)) ?? unprocessedOutputContents
+
+    if (!config.dryRun) {
+      await writeFile(outputPath, finalOutputContents)
+      log(config, LogLevel.Info, "Done.")
+    } else {
+      log(config, LogLevel.Info, "Content output:")
+      log(config, LogLevel.Info, finalOutputContents)
+    }
+  } else if (exists) {
+    log(config, LogLevel.Info, `File ${outputPath} already exists, skipping`)
+  }
+}
+
+export function getOutputDir(config: ScaffoldConfig, outputPathOpt: string, basePath: string): string {
+  return path.resolve(
+    process.cwd(),
+    ...([
+      outputPathOpt,
+      basePath,
+      config.createSubFolder
+        ? config.subFolderNameHelper
+          ? handlebarsParse(config, `{{ ${config.subFolderNameHelper} name }}`).toString()
+          : config.name
+        : undefined,
+    ].filter(Boolean) as string[]),
+  )
+}
+
+export function logInputFile(
+  config: ScaffoldConfig,
+  {
+    origTemplate,
+    relPath,
+    template,
+    inputFilePath,
+    nonGlobTemplate,
+    basePath,
+    isDirOrGlob,
+    isGlob,
+  }: {
+    origTemplate: string
+    relPath: string
+    template: string
+    inputFilePath: string
+    nonGlobTemplate: string
+    basePath: string
+    isDirOrGlob: boolean
+    isGlob: boolean
+  },
+): void {
+  log(
+    config,
+    LogLevel.Debug,
+    `\nprocess.cwd(): ${process.cwd()}`,
+    `\norigTemplate: ${origTemplate}`,
+    `\nrelPath: ${relPath}`,
+    `\ntemplate: ${template}`,
+    `\ninputFilePath: ${inputFilePath}`,
+    `\nnonGlobTemplate: ${nonGlobTemplate}`,
+    `\nbasePath: ${basePath}`,
+    `\nisDirOrGlob: ${isDirOrGlob}`,
+    `\nisGlob: ${isGlob}`,
+    `\n`,
+  )
+}
+
+export function logInitStep(config: ScaffoldConfig): void {
+  log(config, LogLevel.Debug, "Full config:", {
+    name: config.name,
+    templates: config.templates,
+    output: config.output,
+    createSubFolder: config.createSubFolder,
+    data: config.data,
+    overwrite: config.overwrite,
+    quiet: config.quiet,
+    subFolderNameHelper: config.subFolderNameHelper,
+    helpers: Object.keys(config.helpers ?? {}),
+    verbose: `${config.verbose} (${Object.keys(LogLevel).find(
+      (k) => (LogLevel[k as any] as unknown as number) === config.verbose!,
+    )})`,
+    dryRun: config.dryRun,
+    beforeWrite: config.beforeWrite,
+  } as Record<keyof ScaffoldConfig, unknown>)
+  log(config, LogLevel.Info, "Data:", config.data)
+}
+
+export function parseAppendData(value: string, options: ScaffoldCmdConfig & OptionsBase): unknown {
+  const data = options.data ?? {}
+  const [key, val] = value.split(/\:?=/)
+  // raw
+  if (value.includes(":=") && !val.includes(":=")) {
+    return { ...data, [key]: JSON.parse(val) }
+  }
+  return { ...data, [key]: isWrappedWithQuotes(val) ? val.substring(1, val.length - 1) : val }
+}
+
+function isWrappedWithQuotes(string: string): boolean {
+  return (string.startsWith('"') && string.endsWith('"')) || (string.startsWith("'") && string.endsWith("'"))
+}
+
+/** @internal */
+export async function parseConfig(config: ScaffoldCmdConfig & OptionsBase): Promise<ScaffoldConfig> {
+  let c: ScaffoldConfig = config
+  if (config.github) {
+    log(config, LogLevel.Info, `Loading config from github ${config.github}`)
+    const gitUrl = new URL(`https://github.com/${config.github}`)
+    if (!gitUrl.pathname.endsWith(".git")) {
+      gitUrl.pathname += ".git"
+    }
+    config.config = gitUrl.toString()
+  }
+
+  if (config.config) {
+    const isUrl = config.config.includes("://")
+
+    const hasColonToken = (!isUrl && config.config.includes(":")) || (isUrl && count(config.config, ":") > 1)
+    const colonIndex = config.config.lastIndexOf(":")
+    const [configFile, templateKey = "default"] = hasColonToken
+      ? [config.config.substring(0, colonIndex), config.config.substring(colonIndex + 1)]
+      : [config.config, undefined]
+    const key = (config.key ?? templateKey) || "default"
+    log(config, LogLevel.Info, `Loading config from ${configFile} with key ${key}`)
+    const configImport = await getConfig({ config: configFile, quiet: config.quiet, verbose: config.verbose })
+    if (!configImport[key]) {
+      throw new Error(`Template "${key}" not found in ${configFile}`)
+    }
+    c = {
+      ...config,
+      ...configImport[key],
+      data: {
+        ...configImport[key].data,
+        ...config.data,
+      },
+    }
+  }
+
+  c.data = { ...c.data, ...config.appendData }
+  delete config.appendData
+  return c
+}
+
+/** @internal */
+export async function getConfig(
+  config: Pick<ScaffoldCmdConfig, "quiet" | "verbose" | "config">,
+): Promise<ScaffoldConfigFile> {
+  const { config: configFile, ...logConfig } = config as Required<typeof config>
+  const url = new URL(configFile)
+
+  if (url.protocol === "file:") {
+    log(logConfig, LogLevel.Info, `Loading config from file ${configFile}`)
+    const absolutePath = path.resolve(process.cwd(), configFile)
+    return import(absolutePath)
+  }
+
+  const isHttp = url.protocol === "http:" || url.protocol === "https:"
+  const isGit = url.protocol === "git:" || (isHttp && url.pathname.endsWith(".git"))
+
+  if (isHttp || isGit) {
+    if (isGit) {
+      const repoUrl = `${url.protocol}//${url.host}${url.pathname}`
+      log(logConfig, LogLevel.Info, `Cloning git repo ${repoUrl}`)
+      const tmpPath = path.resolve(os.tmpdir(), `scaffold-config-${Date.now()}`)
+
+      return new Promise((resolve, reject) => {
+        const clone = spawn("git", ["clone", "--depth", "1", repoUrl, tmpPath])
+
+        clone.on("error", reject)
+        clone.on("close", async (code) => {
+          if (code === 0) {
+            log(logConfig, LogLevel.Info, `Loading config from git repo: ${repoUrl}`)
+            const hashPath = url.hash?.replace("#", "") || "scaffold.config.js"
+            const absolutePath = path.resolve(tmpPath, hashPath)
+            const loadedConfig = (await import(absolutePath)).default as ScaffoldConfigFile
+            log(logConfig, LogLevel.Info, `Loaded config from git`)
+            log(logConfig, LogLevel.Debug, `Raw config:`, loadedConfig)
+            const fixedConfig: ScaffoldConfigFile = Object.fromEntries(
+              Object.entries(loadedConfig).map(([k, v]) => [
+                k,
+                // use absolute paths for template as config is necessarily in another directory
+                { ...v, templates: v.templates.map((t) => path.resolve(tmpPath, t)) },
+              ]),
+            )
+
+            resolve(fixedConfig)
+          } else {
+            reject(new Error(`Git clone failed with code ${code}`))
+          }
+        })
+      })
+    }
+
+    throw new Error(`Unsupported protocol ${url.protocol}`)
+  }
+
+  return import(path.resolve(process.cwd(), configFile))
+}
+
+function count(string: string, substring: string): number {
+  return string.split(substring).length - 1
+}

tests/scaffold.test.ts

@@ -0,0 +1,502 @@
+import mockFs from "mock-fs"
+import FileSystem from "mock-fs/lib/filesystem"
+import Scaffold from "../src/scaffold"
+import { readdirSync, readFileSync } from "fs"
+import { Console } from "console"
+import { defaultHelpers } from "../src/utils"
+import { join } from "path"
+import * as dateFns from "date-fns"
+import crypto from "crypto"
+
+const fileStructNormal = {
+  input: {
+    "{{name}}.txt": "Hello, my app is {{name}}",
+  },
+  output: {},
+}
+const fileStructWithBinary = {
+  input: {
+    "{{name}}.txt": "Hello, my app is {{name}}",
+    "{{name}}.bin": crypto.randomBytes(10000),
+  },
+  output: {},
+}
+
+const fileStructWithData = {
+  input: {
+    "{{name}}.txt": "Hello, my value is {{value}}",
+  },
+  output: {},
+}
+
+const fileStructNested = {
+  input: {
+    "{{name}}-1.txt": "This should be in root",
+    "{{Name}}": {
+      "{{name}}-2.txt": "Hello, my value is {{value}}",
+      moreNesting: {
+        "{{name}}-3.txt": "Hi! My value is actually NOT {{value}}!",
+      },
+    },
+  },
+  output: {},
+}
+const fileStructSubdirTransformer = {
+  input: {
+    "{{name}}.txt": "Hello, my app is {{name}}",
+  },
+  output: {},
+}
+
+const defaultHelperNames = Object.keys(defaultHelpers)
+const fileStructHelpers = {
+  input: {
+    defaults: defaultHelperNames.reduce<Record<string, string>>(
+      (all, cur) => ({ ...all, [cur + ".txt"]: `{{ ${cur} name }}` }),
+      {},
+    ),
+    custom: {
+      "add1.txt": "{{ add1 name }}",
+    },
+  },
+  output: {},
+}
+
+const fileStructDates = {
+  input: {
+    "now.txt": "Today is {{ now 'mmm' }}, time is {{ now 'HH:mm' }}",
+    "offset.txt": "Yesterday was {{ now 'mmm' -1 'days' }}, time is {{ now 'HH:mm' -1 'days' }}",
+    "custom.txt": "Custom date is {{ date customDate 'mmm' }}, time is {{ date customDate 'HH:mm' }}",
+  },
+  output: {},
+}
+
+function withMock(fileStruct: FileSystem.DirectoryItems, testFn: jest.EmptyFunction): jest.EmptyFunction {
+  return () => {
+    beforeEach(() => {
+      // console.log("Mocking:", fileStruct)
+      console = new Console(process.stdout, process.stderr)
+
+      mockFs(fileStruct)
+      // logMock = jest.spyOn(console, 'log').mockImplementation((...args) => {
+      //   logsTemp.push(args)
+      // })
+    })
+    testFn()
+    afterEach(() => {
+      // console.log("Restoring mock")
+      mockFs.restore()
+    })
+  }
+}
+
+describe("Scaffold", () => {
+  describe(
+    "create subfolder",
+    withMock(fileStructNormal, () => {
+      test("should not create by default", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          verbose: 0,
+        })
+        const data = readFileSync(join(process.cwd(), "output", "app_name.txt"))
+        expect(data.toString()).toEqual("Hello, my app is app_name")
+      })
+
+      test("should create with config", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          createSubFolder: true,
+          verbose: 0,
+        })
+
+        const data = readFileSync(join(process.cwd(), "output", "app_name", "app_name.txt"))
+        expect(data.toString()).toEqual("Hello, my app is app_name")
+      })
+    }),
+  )
+
+  describe(
+    "binary files",
+    withMock(fileStructWithBinary, () => {
+      test("should copy as-is", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          verbose: 0,
+        })
+        const data = readFileSync(join(process.cwd(), "output", "app_name.txt"))
+        expect(data.toString()).toEqual("Hello, my app is app_name")
+        const dataBin = readFileSync(join(process.cwd(), "output", "app_name.bin"))
+        expect(dataBin).toEqual(fileStructWithBinary.input["{{name}}.bin"])
+      })
+    }),
+  )
+
+  describe(
+    "overwrite",
+    withMock(fileStructWithData, () => {
+      test("should not overwrite by default", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          data: { value: "1" },
+          verbose: 0,
+        })
+
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          data: { value: "2" },
+          verbose: 0,
+        })
+
+        const data = readFileSync(join(process.cwd(), "output", "app_name.txt"))
+        expect(data.toString()).toEqual("Hello, my value is 1")
+      })
+
+      test("should overwrite with config", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          data: { value: "1" },
+          verbose: 0,
+        })
+
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          data: { value: "2" },
+          overwrite: true,
+          verbose: 0,
+        })
+
+        const data = readFileSync(join(process.cwd(), "output", "app_name.txt"))
+        expect(data.toString()).toEqual("Hello, my value is 2")
+      })
+    }),
+  )
+
+  describe(
+    "errors",
+    withMock(fileStructNormal, () => {
+      let consoleMock1: jest.SpyInstance
+      beforeAll(() => {
+        consoleMock1 = jest.spyOn(console, "error").mockImplementation(() => void 0)
+      })
+
+      afterAll(() => {
+        consoleMock1.mockRestore()
+      })
+
+      test("should throw for bad input", async () => {
+        await expect(
+          Scaffold({
+            name: "app_name",
+            output: "output",
+            templates: ["non-existing-input"],
+            data: { value: "1" },
+            verbose: 0,
+          }),
+        ).rejects.toThrow()
+
+        await expect(
+          Scaffold({
+            name: "app_name",
+            output: "output",
+            templates: ["non-existing-input/non-existing-file.txt"],
+            data: { value: "1" },
+            verbose: 0,
+          }),
+        ).rejects.toThrow()
+
+        expect(() => readFileSync(join(process.cwd(), "output", "app_name.txt"))).toThrow()
+      })
+    }),
+  )
+
+  describe(
+    "dry run",
+    withMock(fileStructNormal, () => {
+      let consoleMock1: jest.SpyInstance
+      beforeAll(() => {
+        consoleMock1 = jest.spyOn(console, "error").mockImplementation(() => void 0)
+      })
+
+      afterAll(() => {
+        consoleMock1.mockRestore()
+      })
+
+      test("should not write to disk", async () => {
+        Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          data: { value: "1" },
+          verbose: 0,
+          dryRun: true,
+        })
+
+        expect(() => readFileSync(join(process.cwd(), "output", "app_name.txt"))).toThrow()
+      })
+    }),
+  )
+
+  describe(
+    "outputPath override",
+    withMock(fileStructNormal, () => {
+      test("should allow override function", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: (fullPath, basedir, basename) => join("custom-output", `${basename.split(".")[0]}`),
+          templates: ["input"],
+          data: { value: "1" },
+          verbose: 0,
+        })
+        const data = readFileSync(join(process.cwd(), "/custom-output/app_name/app_name.txt"))
+        expect(data.toString()).toEqual("Hello, my app is app_name")
+      })
+    }),
+  )
+
+  describe(
+    "output structure",
+    withMock(fileStructNested, () => {
+      test("should maintain input structure on output", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          data: { value: "1" },
+          verbose: 0,
+        })
+
+        const rootDir = readdirSync(join(process.cwd(), "output"))
+        const dir = readdirSync(join(process.cwd(), "output", "AppName"))
+        const nestedDir = readdirSync(join(process.cwd(), "output", "AppName", "moreNesting"))
+        expect(rootDir).toHaveProperty("length")
+        expect(dir).toHaveProperty("length")
+        expect(nestedDir).toHaveProperty("length")
+
+        const rootFile = readFileSync(join(process.cwd(), "output", "app_name-1.txt"))
+        const oneDeepFile = readFileSync(join(process.cwd(), "output", "AppName/app_name-2.txt"))
+        const twoDeepFile = readFileSync(join(process.cwd(), "output", "AppName/moreNesting/app_name-3.txt"))
+        expect(rootFile.toString()).toEqual("This should be in root")
+        expect(oneDeepFile.toString()).toEqual("Hello, my value is 1")
+        expect(twoDeepFile.toString()).toEqual("Hi! My value is actually NOT 1!")
+      })
+    }),
+  )
+
+  describe(
+    "capitalization helpers",
+    withMock(fileStructHelpers, () => {
+      const _helpers: Record<string, (text: string) => string> = {
+        add1: (text) => text + " 1",
+      }
+
+      test("should work", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          verbose: 0,
+          helpers: _helpers,
+        })
+
+        const results = {
+          camelCase: "appName",
+          snakeCase: "app_name",
+          startCase: "App Name",
+          kebabCase: "app-name",
+          hyphenCase: "app-name",
+          pascalCase: "AppName",
+          lowerCase: "app_name",
+          upperCase: "APP_NAME",
+        }
+        for (const key in results) {
+          const file = readFileSync(join(process.cwd(), "output", "defaults", `${key}.txt`))
+          expect(file.toString()).toEqual(results[key as keyof typeof results])
+        }
+      })
+    }),
+  )
+  describe(
+    "date helpers",
+    withMock(fileStructDates, () => {
+      test("should work", async () => {
+        const now = new Date()
+        const yesterday = dateFns.add(new Date(), { days: -1 })
+        const customDate = dateFns.formatISO(dateFns.add(new Date(), { days: -1 }))
+
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          verbose: 0,
+          data: { customDate },
+        })
+
+        const nowFile = readFileSync(join(process.cwd(), "output", "now.txt"))
+        const offsetFile = readFileSync(join(process.cwd(), "output", "offset.txt"))
+        const customFile = readFileSync(join(process.cwd(), "output", "custom.txt"))
+
+        // "now.txt": "Today is {{ now 'mmm' }}, time is {{ now 'HH:mm' }}",
+        // "offset.txt": "Yesterday was {{ now 'mmm' -1 'days' }}, time is {{ now 'HH:mm' -1 'days' }}",
+        // "custom.txt": "Custom date is {{ date customDate 'mmm' }}, time is {{ date customDate 'HH:mm' }}",
+
+        expect(nowFile.toString()).toEqual(
+          `Today is ${dateFns.format(now, "mmm")}, time is ${dateFns.format(now, "HH:mm")}`,
+        )
+        expect(offsetFile.toString()).toEqual(
+          `Yesterday was ${dateFns.format(yesterday, "mmm")}, time is ${dateFns.format(yesterday, "HH:mm")}`,
+        )
+        expect(customFile.toString()).toEqual(
+          `Custom date is ${dateFns.format(dateFns.parseISO(customDate), "mmm")}, time is ${dateFns.format(
+            dateFns.parseISO(customDate),
+            "HH:mm",
+          )}`,
+        )
+      })
+    }),
+  )
+  describe(
+    "custom helpers",
+    withMock(fileStructHelpers, () => {
+      const _helpers: Record<string, (text: string) => string> = {
+        add1: (text) => text + " 1",
+      }
+      test("should work", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          verbose: 0,
+          helpers: _helpers,
+        })
+
+        const results = {
+          add1: "app_name 1",
+        }
+        for (const key in results) {
+          const file = readFileSync(join(process.cwd(), "output", "custom", `${key}.txt`))
+          expect(file.toString()).toEqual(results[key as keyof typeof results])
+        }
+      })
+    }),
+  )
+  describe(
+    "transform subfolder",
+    withMock(fileStructSubdirTransformer, () => {
+      test("should work with no helper", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          createSubFolder: true,
+          verbose: 0,
+        })
+
+        const data = readFileSync(join(process.cwd(), "output", "app_name", "app_name.txt"))
+        expect(data.toString()).toEqual("Hello, my app is app_name")
+      })
+
+      test("should work with default helper", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          createSubFolder: true,
+          verbose: 0,
+          subFolderNameHelper: "upperCase",
+        })
+
+        const data = readFileSync(join(process.cwd(), "output", "APP_NAME", "app_name.txt"))
+        expect(data.toString()).toEqual("Hello, my app is app_name")
+      })
+
+      test("should work with custom helper", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          createSubFolder: true,
+          verbose: 0,
+          subFolderNameHelper: "test",
+          helpers: {
+            test: () => "REPLACED",
+          },
+        })
+
+        const data = readFileSync(join(process.cwd(), "output", "REPLACED", "app_name.txt"))
+        expect(data.toString()).toEqual("Hello, my app is app_name")
+      })
+    }),
+  )
+  describe(
+    "before write",
+    withMock(fileStructNormal, () => {
+      test("should work with no callback", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          verbose: 0,
+          data: {
+            value: "value",
+          },
+        })
+
+        const data = readFileSync(join(process.cwd(), "output", "app_name.txt"))
+        expect(data.toString()).toEqual("Hello, my app is app_name")
+      })
+
+      test("should work with custom callback", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          verbose: 0,
+          data: {
+            value: "value",
+          },
+          beforeWrite: (content, beforeContent, outputPath) =>
+            [content.toString().toUpperCase(), beforeContent, outputPath].join(", "),
+        })
+
+        const data = readFileSync(join(process.cwd(), "output", "app_name.txt"))
+        expect(data.toString()).toEqual(
+          [
+            "Hello, my app is app_name".toUpperCase(),
+            fileStructNormal.input["{{name}}.txt"],
+            join(process.cwd(), "output", "app_name.txt"),
+          ].join(", "),
+        )
+      })
+      test("should work with undefined response custom callback", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          verbose: 0,
+          data: {
+            value: "value",
+          },
+          beforeWrite: () => undefined,
+        })
+
+        const data = readFileSync(join(process.cwd(), "output", "app_name.txt"))
+        expect(data.toString()).toEqual("Hello, my app is app_name")
+      })
+    }),
+  )
+})

tests/utils.test.ts

@@ -0,0 +1,124 @@
+import { dateHelper, handlebarsParse, nowHelper, parseAppendData } from "../src/utils"
+import { ScaffoldCmdConfig, ScaffoldConfig } from "../src/types"
+import path from "path"
+import * as dateFns from "date-fns"
+import { OptionsBase } from "massarg/types"
+
+const blankConf: ScaffoldConfig = {
+  verbose: 0,
+  name: "",
+  output: "",
+  templates: [],
+  data: { name: "test" },
+}
+
+const blankCliConf: ScaffoldCmdConfig & OptionsBase = {
+  verbose: 0,
+  name: "",
+  output: "",
+  templates: [],
+  data: { name: "test" },
+  overwrite: false,
+  createSubFolder: false,
+  dryRun: false,
+  quiet: false,
+  extras: [],
+  help: false,
+}
+
+describe("Utils", () => {
+  describe("handlebarsParse", () => {
+    let origSep: any
+    describe("windows paths", () => {
+      beforeAll(() => {
+        origSep = path.sep
+        Object.defineProperty(path, "sep", { value: "\\" })
+      })
+      afterAll(() => {
+        Object.defineProperty(path, "sep", { value: origSep })
+      })
+      test("should work for windows paths", async () => {
+        expect(handlebarsParse(blankConf, "C:\\exports\\{{name}}.txt", { isPath: true })).toEqual(
+          Buffer.from("C:\\exports\\test.txt"),
+        )
+      })
+    })
+    describe("non-windows paths", () => {
+      beforeAll(() => {
+        origSep = path.sep
+        Object.defineProperty(path, "sep", { value: "/" })
+      })
+      afterAll(() => {
+        Object.defineProperty(path, "sep", { value: origSep })
+      })
+      test("should work for non-windows paths", async () => {
+        expect(handlebarsParse(blankConf, "/home/test/{{name}}.txt", { isPath: true })).toEqual(
+          Buffer.from("/home/test/test.txt"),
+        )
+      })
+    })
+    test("should not do path escaping on non-path compiles", async () => {
+      expect(
+        handlebarsParse(
+          { ...blankConf, data: { ...blankConf.data, escaped: "value" } },
+          "/home/test/{{name}} \\{{escaped}}.txt",
+          {
+            isPath: false,
+          },
+        ),
+      ).toEqual(Buffer.from("/home/test/test {{escaped}}.txt"))
+    })
+  })
+
+  describe("Helpers", () => {
+    describe("date helpers", () => {
+      describe("now", () => {
+        test("should work without extra params", () => {
+          const now = new Date()
+          const fmt = "yyyy-MM-dd HH:mm"
+
+          expect(nowHelper(fmt)).toEqual(dateFns.format(now, fmt))
+        })
+      })
+
+      describe("date", () => {
+        test("should work with no offset params", () => {
+          const now = new Date()
+          const fmt = "yyyy-MM-dd HH:mm"
+
+          expect(dateHelper(now.toISOString(), fmt)).toEqual(dateFns.format(now, fmt))
+        })
+
+        test("should work with offset params", () => {
+          const now = new Date()
+          const fmt = "yyyy-MM-dd HH:mm"
+
+          expect(dateHelper(now.toISOString(), fmt, -1, "days")).toEqual(
+            dateFns.format(dateFns.add(now, { days: -1 }), fmt),
+          )
+          expect(dateHelper(now.toISOString(), fmt, 1, "months")).toEqual(
+            dateFns.format(dateFns.add(now, { months: 1 }), fmt),
+          )
+        })
+      })
+    })
+  })
+
+  describe("parseAppendData", () => {
+    test('works for "key=value"', () => {
+      expect(parseAppendData("key=value", blankCliConf)).toEqual({ key: "value", name: "test" })
+    })
+
+    test('works for "key:=value"', () => {
+      expect(parseAppendData("key:=123", blankCliConf)).toEqual({ key: 123, name: "test" })
+    })
+
+    test("overwrites existing value", () => {
+      expect(parseAppendData("name:=123", blankCliConf)).toEqual({ name: 123 })
+    })
+
+    test("works with quotes", () => {
+      expect(parseAppendData('key="value test"', blankCliConf)).toEqual({ key: "value test", name: "test" })
+    })
+  })
+})

tsconfig.json

@@ -1,13 +1,16 @@
 {
   "compilerOptions": {
-    "target": "es5",
-    "module": "es2015",
+    "target": "ES2019",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "lib": ["ES2019"],
     "declaration": true,
-    "outDir": "./dist",
+    "outDir": "dist",
     "strict": true,
-    "sourceMap": true
+    "sourceMap": true,
+    "removeComments": false
   },
-  "exclude": [
-    "examples"
-  ]
+  "include": ["src/index.ts", "src/cmd.ts"],
+  "exclude": ["tests/*"]
 }

typedoc.config.js

@@ -0,0 +1,63 @@
+const path = require("path")
+
+/** @type {import('typedoc').TypeDocOptions} */
+module.exports = {
+  name: "Simple Scaffold",
+  entryPoints: ["src/index.ts"],
+  includeVersion: true,
+  categorizeByGroup: false,
+  sort: ["visibility"],
+  categoryOrder: ["Main", "*"],
+  media: "media",
+  githubPages: true,
+  entryPointStrategy: "expand",
+  out: "docs",
+  excludePrivate: true,
+  excludeProtected: true,
+  excludeInternal: true,
+  gaID: "GTM-KHQS9TQ",
+  validation: {
+    invalidLink: true,
+  },
+  plugin: ["@knodes/typedoc-plugin-pages"],
+  customCss: "src/docs.css",
+  options: "typedoc.config.js",
+  logLevel: "Verbose",
+  pluginPages: {
+    logLevel: "Verbose",
+    pages: [
+      {
+        name: "Configuration",
+        source: "README.md",
+        childrenDir: path.join(process.cwd(), "pages"),
+        childrenOutputDir: "./",
+        children: [
+          {
+            name: "CLI usage",
+            source: "cli.md",
+          },
+          {
+            name: "Node.js usage",
+            source: "node.md",
+          },
+          {
+            name: "Templates",
+            source: "templates.md",
+          },
+          {
+            name: "Configuration Files",
+            source: "configuration_files.md",
+          },
+          {
+            name: "Migrating v0.x to v1.x",
+            source: "migration.md",
+          },
+        ],
+      },
+      {
+        name: "Changelog",
+        source: "./CHANGELOG.md",
+      },
+    ],
+  },
+}

webpack.config.js

@@ -1,22 +0,0 @@
-const path = require('path')
-
-module.exports = {
-  target: 'node',
-  entry: './scaffold.ts',
-  output: {
-    filename: 'scaffold.js',
-    path: path.resolve(__dirname, 'dist')
-  },
-  resolve: {
-    extensions: ['.ts']
-  },
-  module: {
-    rules: [
-      {
-        test: /\.tsx?$/,
-        loader: 'ts-loader',
-        exclude: ['./examples']
-      }
-    ]
-  }
-}