@nabilabs/create-builder 0.1.0

package/dist/index.js

@@ -0,0 +1,293 @@
+// src/index.ts
+import { spawn } from "node:child_process";
+import { access, cp, lstat, readdir, readFile, rename, writeFile } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/errors.ts
+class CreateBuilderError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CreateBuilderError";
+  }
+}
+
+// src/index.ts
+var templatesDirectory = resolve(dirname(fileURLToPath(import.meta.url)), "../templates");
+var packageManagerVariable = /\{\{packageManager\}\}/g;
+var templateVariable = /\{\{projectName\}\}/g;
+var packageManagerFromUserAgent = (userAgent) => {
+  const invokingUserAgent = userAgent ?? process.env.npm_config_user_agent;
+  if (invokingUserAgent?.startsWith("bun/"))
+    return "bun";
+  if (invokingUserAgent?.startsWith("pnpm/"))
+    return "pnpm";
+  if (invokingUserAgent?.startsWith("yarn/"))
+    return "yarn";
+  if (userAgent === undefined && process.versions.bun)
+    return "bun";
+  return "npm";
+};
+var packageManagerSpecificationFromUserAgent = (packageManager, userAgent) => {
+  const invokingUserAgent = userAgent ?? process.env.npm_config_user_agent;
+  const version = invokingUserAgent?.match(new RegExp(`(?:^|\\s)${packageManager}/([^\\s]+)`))?.[1];
+  const runtimeVersion = packageManager === "bun" ? process.versions.bun : undefined;
+  const resolvedVersion = version ?? runtimeVersion;
+  return resolvedVersion ? `${packageManager}@${resolvedVersion}` : packageManager;
+};
+var isMissing = (error) => error instanceof Error && ("code" in error) && error.code === "ENOENT";
+var validateProjectName = (projectName) => {
+  const name = projectName.trim();
+  if (!name)
+    throw new CreateBuilderError("Project name cannot be empty.");
+  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(name)) {
+    throw new CreateBuilderError("Project name may only contain letters, numbers, dots, underscores, and hyphens.");
+  }
+  if (name === "." || name === "..")
+    throw new CreateBuilderError("Project name must name a new directory.");
+  return name;
+};
+var getTemplatePath = async (template) => {
+  if (!/^[a-z0-9][a-z0-9-]*$/i.test(template))
+    throw new CreateBuilderError(`Invalid template: ${template}`);
+  const path = resolve(templatesDirectory, template);
+  if (dirname(path) !== templatesDirectory)
+    throw new CreateBuilderError(`Invalid template: ${template}`);
+  try {
+    const stats = await lstat(path);
+    if (!stats.isDirectory())
+      throw new CreateBuilderError(`Template is not a directory: ${template}`);
+  } catch (error) {
+    if (isMissing(error))
+      throw new CreateBuilderError(`Unknown template: ${template}`);
+    throw error;
+  }
+  return path;
+};
+var getTemplateNames = async () => {
+  const entries = await readdir(templatesDirectory, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((first, second) => first.localeCompare(second));
+};
+var validateTargetDirectory = async ({
+  cwd,
+  projectName
+}) => {
+  const directory = resolve(cwd, projectName);
+  if (basename(directory) !== projectName)
+    throw new CreateBuilderError("Project name must not contain a path.");
+  try {
+    await access(directory);
+  } catch (error) {
+    if (isMissing(error))
+      return directory;
+    throw error;
+  }
+  throw new CreateBuilderError(`Directory already exists: ${directory}`);
+};
+var validateCurrentDirectory = async (directory) => {
+  const stats = await lstat(directory);
+  if (!stats.isDirectory())
+    throw new CreateBuilderError(`Current path is not a directory: ${directory}`);
+  const entries = await readdir(directory);
+  let hasPackageManifest = false;
+  for (const entry of entries) {
+    const path = resolve(directory, entry);
+    const entryStats = await lstat(path);
+    if (entry === "package.json" && entryStats.isFile()) {
+      hasPackageManifest = true;
+      continue;
+    }
+    if (entry === "node_modules" && entryStats.isDirectory())
+      continue;
+    throw new CreateBuilderError(`Current directory may only contain package.json and node_modules: ${directory}`);
+  }
+  return hasPackageManifest;
+};
+var resolveProjectTarget = async ({
+  cwd,
+  projectName
+}) => {
+  if (projectName === "." || projectName === "./") {
+    const directory = resolve(cwd);
+    const hasPackageManifest = await validateCurrentDirectory(directory);
+    return {
+      directory,
+      hasPackageManifest,
+      isCurrentDirectory: true,
+      projectName: validateProjectName(basename(directory))
+    };
+  }
+  const name = validateProjectName(projectName);
+  return {
+    directory: await validateTargetDirectory({ cwd, projectName: name }),
+    hasPackageManifest: false,
+    isCurrentDirectory: false,
+    projectName: name
+  };
+};
+var copyTemplate = async ({
+  destination,
+  destinationExists = false,
+  skipPackageManifest = false,
+  source
+}) => {
+  try {
+    if (destinationExists) {
+      const entries = (await readdir(source)).filter((entry) => !skipPackageManifest || entry !== "package.json");
+      await Promise.all(entries.map((entry) => cp(resolve(source, entry), resolve(destination, entry), {
+        errorOnExist: true,
+        force: false,
+        recursive: true
+      })));
+    } else {
+      await cp(source, destination, {
+        errorOnExist: true,
+        force: false,
+        recursive: true
+      });
+    }
+    await rename(resolve(destination, "gitignore"), resolve(destination, ".gitignore"));
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "EEXIST") {
+      throw new CreateBuilderError(`Directory already exists: ${destination}`);
+    }
+    throw error;
+  }
+};
+var isManifest = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readPackageManifest = async (path) => {
+  try {
+    const manifest = JSON.parse(await readFile(path, "utf8"));
+    if (!isManifest(manifest))
+      throw new CreateBuilderError(`Invalid package.json: ${path}`);
+    return manifest;
+  } catch (error) {
+    if (error instanceof SyntaxError)
+      throw new CreateBuilderError(`Invalid package.json: ${path}`);
+    throw error;
+  }
+};
+var manifestSection = (manifest, section) => {
+  const value = manifest[section];
+  if (value === undefined)
+    return {};
+  if (!isManifest(value))
+    throw new CreateBuilderError(`Invalid package.json ${section}.`);
+  return value;
+};
+var mergePackageManifest = async ({
+  directory,
+  packageManagerSpecification,
+  projectName,
+  templatePath
+}) => {
+  const path = resolve(directory, "package.json");
+  const [existing, templateManifest] = await Promise.all([
+    readPackageManifest(path),
+    readPackageManifest(resolve(templatePath, "package.json"))
+  ]);
+  const manifest = {
+    ...templateManifest,
+    ...existing,
+    devDependencies: {
+      ...manifestSection(existing, "devDependencies"),
+      ...manifestSection(templateManifest, "devDependencies")
+    },
+    name: projectName,
+    packageManager: packageManagerSpecification,
+    scripts: {
+      ...manifestSection(existing, "scripts"),
+      ...manifestSection(templateManifest, "scripts")
+    }
+  };
+  await writeFile(path, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+};
+var getFiles = async (directory) => {
+  const entries = await readdir(directory, { withFileTypes: true });
+  const paths = await Promise.all(entries.filter((entry) => entry.name !== "node_modules").map(async (entry) => {
+    const path = resolve(directory, entry.name);
+    if (entry.isDirectory())
+      return getFiles(path);
+    return [path];
+  }));
+  return paths.flat();
+};
+var replaceTemplateVariables = async ({
+  directory,
+  packageManagerSpecification,
+  projectName
+}) => {
+  const files = await getFiles(directory);
+  await Promise.all(files.map(async (path) => {
+    const source = await readFile(path, "utf8");
+    const result = source.replace(templateVariable, projectName).replace(packageManagerVariable, packageManagerSpecification);
+    if (result !== source)
+      await writeFile(path, result, "utf8");
+  }));
+};
+var installDependencies = async (directory, packageManager) => {
+  await new Promise((resolve2, reject) => {
+    const child = spawn(packageManager, ["install"], {
+      cwd: directory,
+      shell: process.platform === "win32",
+      stdio: "inherit"
+    });
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      if (code === 0)
+        return resolve2();
+      reject(new CreateBuilderError("Dependency installation failed."));
+    });
+  });
+};
+var createProject = async ({
+  cwd = process.cwd(),
+  install = installDependencies,
+  packageManager = "npm",
+  packageManagerSpecification = packageManager,
+  projectName,
+  template = "default"
+}) => {
+  const target = await resolveProjectTarget({ cwd, projectName });
+  const source = await getTemplatePath(template);
+  if (target.hasPackageManifest)
+    await readPackageManifest(resolve(target.directory, "package.json"));
+  await copyTemplate({
+    destination: target.directory,
+    destinationExists: target.isCurrentDirectory,
+    skipPackageManifest: target.hasPackageManifest,
+    source
+  });
+  await replaceTemplateVariables({
+    directory: target.directory,
+    packageManagerSpecification,
+    projectName: target.projectName
+  });
+  if (target.hasPackageManifest) {
+    await mergePackageManifest({
+      directory: target.directory,
+      packageManagerSpecification,
+      projectName: target.projectName,
+      templatePath: source
+    });
+  }
+  await install(target.directory, packageManager);
+  return {
+    directory: target.directory,
+    projectName: target.projectName,
+    template
+  };
+};
+export {
+  validateTargetDirectory,
+  validateProjectName,
+  replaceTemplateVariables,
+  packageManagerSpecificationFromUserAgent,
+  packageManagerFromUserAgent,
+  installDependencies,
+  getTemplatePath,
+  getTemplateNames,
+  createProject,
+  copyTemplate
+};

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@nabilabs/create-builder",
+  "version": "0.1.0",
+  "publisher": "Nabi Labs",
+  "displayName": "Nabi Builder - Create",
+  "description": "Create a new Nabi Builder project",
+  "type": "module",
+  "license": "MIT",
+  "packageManager": "bun",
+  "bin": {
+    "create-builder": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "bun run scripts/build.ts",
+    "----------": "----------",
+    "lint": "eslint . --fix",
+    "lint:check": "eslint . --max-warnings 0",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "typecheck": "bunx tsc --noEmit",
+    "test": "bun test",
+    "pack:check": "bun pm pack --dry-run --ignore-scripts",
+    "-----------": "-----------",
+    "fix": "bun run lint && bun run format",
+    "check": "bun run typecheck && bun run lint:check && bun run format:check && bun run test && bun run build && bun run pack:check",
+    "------------": "------------",
+    "prepack": "bun run build",
+    "prepublishOnly": "bun run check",
+    "prepare": "bun run scripts/prepare.ts"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.0",
+    "@types/bun": "^1.4.0",
+    "@types/node": "^22.20.1",
+    "dts-bundle-generator": "^9.5.1",
+    "eslint": "^9.39.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.5",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-perfectionist": "^5.10.1",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "globals": "^17.4.0",
+    "husky": "^9.1.7",
+    "jiti": "^2.7.0",
+    "prettier": "^3.8.1",
+    "typescript": "5.9.3",
+    "typescript-eslint": "^8.68.0"
+  },
+  "keywords": [
+    "nabi",
+    "builder",
+    "html",
+    "ssg",
+    "static-site-generator",
+    "components",
+    "build-tool",
+    "create"
+  ],
+  "files": [
+    "dist",
+    "templates",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nabilabshq/create-builder.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nabilabshq/create-builder/issues"
+  },
+  "homepage": "https://github.com/nabilabshq/create-builder#readme"
+}

package/templates/default/.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false

package/templates/default/.prettierrc

@@ -0,0 +1,6 @@
+{
+  "semi": true,
+  "singleQuote": false,
+  "tabWidth": 2,
+  "trailingComma": "all"
+}

package/templates/default/README.md

@@ -0,0 +1,22 @@
+# {{projectName}}
+
+Two-page static website built with [Nabi Builder](https://github.com/nabilabshq/builder).
+
+## Commands
+
+```bash
+npm run dev
+npm run build
+npm run check
+```
+
+With pnpm, use `pnpm run <script>`; with Yarn, use `yarn <script>`.
+
+Start in `src/pages/index.html`. The template also includes the global `ui/head` component and `shared/styles/normalize.css`.
+
+## Routes
+
+- `/` — `src/pages/index.html`
+- `/about` — `src/pages/about/index.html`
+
+The template demonstrates shared UI components, colocated CSS, and assets referenced through `@assets`.

package/templates/default/eslint.config.js

@@ -0,0 +1,15 @@
+import js from "@eslint/js";
+import globals from "globals";
+
+export default [
+  { ignores: ["dist", "node_modules"] },
+  js.configs.recommended,
+  {
+    files: ["src/**/*.js"],
+    languageOptions: {
+      ecmaVersion: "latest",
+      globals: globals.browser,
+      sourceType: "module",
+    },
+  },
+];

package/templates/default/gitignore

@@ -0,0 +1,3 @@
+node_modules/
+dist/
+.nabi*

package/templates/default/nabi.config.js

@@ -0,0 +1,7 @@
+/** @type {import('@nabilabs/builder').NabiConfigInput} */
+export default {
+  minify: {
+    css: true,
+    html: true,
+  },
+};

package/templates/default/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "{{projectName}}",
+  "version": "0.1.0",
+  "private": true,
+  "packageManager": "{{packageManager}}",
+  "type": "module",
+  "scripts": {
+    "dev": "nabi dev",
+    "build": "nabi build",
+    "build:inline": "nabi build --mode inline",
+    "lint": "eslint . && stylelint \"src/**/*.css\"",
+    "format": "prettier . --write",
+    "check": "eslint . --max-warnings 0 && stylelint \"src/**/*.css\" && prettier . --check"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.0",
+    "@nabilabs/builder": "^0.2.0",
+    "eslint": "^9.39.0",
+    "globals": "^17.4.0",
+    "prettier": "^3.8.1",
+    "stylelint": "^16.24.0",
+    "stylelint-config-standard": "^39.0.0"
+  }
+}

package/templates/default/src/pages/about/index.html

@@ -0,0 +1,78 @@
+<!doctype html>
+<html lang="en">
+  <use
+    ref="ui/head"
+    title="About — {{projectName}}"
+    description="The second page of this Nabi Builder starter project."
+  >
+    <link use="base.css" />
+  </use>
+
+  <body>
+    <use ref="ui/header" active="about" />
+
+    <main class="shell about">
+      <section class="about__hero">
+        <p class="eyebrow">About this sample</p>
+        <h1>
+          Multi-page
+          <span>without the machinery.</span>
+        </h1>
+
+        <p class="about__lead">
+          This page exists because there is an
+          <code>about/index.html</code> file. The shared header and footer are
+          resolved during the build, not in the browser.
+        </p>
+      </section>
+
+      <section class="principles">
+        <article class="principle principle--wide">
+          <div>
+            <span class="principle__index">01</span>
+            <p class="principle__label">Routing</p>
+          </div>
+
+          <div>
+            <h2>Folders become URLs.</h2>
+            <p>
+              Put a page at <code>src/pages/about/index.html</code> and Nabi
+              emits the <code>/about</code> route.
+            </p>
+          </div>
+        </article>
+
+        <article class="principle">
+          <span class="principle__index">02</span>
+          <p class="principle__label">Components</p>
+          <h2>Shared once.</h2>
+          <p>
+            The same <code>ui/header</code> component is used on both pages with
+            a different <code>active</code> prop.
+          </p>
+        </article>
+
+        <article class="principle principle--accent">
+          <span class="principle__index">03</span>
+          <p class="principle__label">Runtime</p>
+          <strong>0</strong>
+          <p>No client-side component runtime is required to render this UI.</p>
+        </article>
+      </section>
+
+      <section class="back">
+        <div>
+          <p class="eyebrow">That is the whole demo</p>
+          <h2>Small enough to read in a minute.</h2>
+        </div>
+
+        <a href="/">
+          Back home
+          <span aria-hidden="true">↗</span>
+        </a>
+      </section>
+    </main>
+
+    <use ref="ui/footer" />
+  </body>
+</html>