@gozenc/packer 1.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,243 @@
+# @gozenc/packer
+
+A CLI tool with essential package builder scripts for React library projects. Streamline your React library development workflow with version management, documentation syncing, and package testing utilities.
+
+## Features
+
+- 🔢 **Version Bumping**: Interactive or automated version updates across package files
+- 📚 **Documentation Sync**: Automatically sync built documentation to GitHub Pages
+- 🧪 **Package Testing**: Verify package structure and test locally before publishing
+- 🌐 **Browser Testing**: Local development server for testing built packages
+- ⚡ **Zero Config**: Works out of the box with standard React library setups
+
+## Installation
+
+Install globally to use across all your projects:
+
+```bash
+npm install -g @gozenc/packer
+```
+
+Or install as a dev dependency in your project:
+
+```bash
+npm install --save-dev @gozenc/packer
+```
+
+## Usage
+
+### Global Installation
+
+If installed globally, use the `packer` command directly:
+
+```bash
+packer <command> [options]
+```
+
+### Local Installation
+
+If installed locally, add scripts to your `package.json`:
+
+```json
+{
+  "scripts": {
+    "bump": "packer bump",
+    "docs": "packer docs",
+    "verify": "packer verify",
+    "preview": "packer preview"
+  }
+}
+```
+
+Then run with npm:
+
+```bash
+npm run bump
+```
+
+## Commands
+
+### `packer bump [version]`
+
+Bump the package version across all relevant files.
+
+**Interactive mode** (prompts for version):
+
+```bash
+packer bump
+```
+
+**Direct version** (specify version):
+
+```bash
+packer bump 1.2.3
+```
+
+Updates:
+
+- `package.json`
+- `package-lock.json`
+- `docs.html` (softwareVersion in JSON-LD, if exists)
+- `docs/index.html` (softwareVersion in JSON-LD, if exists)
+
+### `packer docs`
+
+Sync documentation from `docs.html` to `docs/` directory for GitHub Pages or Cloudflare Pages.
+
+```bash
+packer docs
+```
+
+This command:
+
+- Copies `docs.html` → `docs/index.html`
+- Copies `dist/` → `docs/dist/`
+
+**Configuration Options:**
+
+```bash
+packer docs --dist=build --docs-dir=public --docs-file=index.html
+```
+
+Available parameters:
+
+- `--dist` - Build directory (default: `dist`)
+- `--docs-dir` - Documentation output directory (default: `docs`)
+- `--docs-file` - Source HTML file (default: `docs.html`)
+
+**Note**: The `docs/` folder should be added to `.gitignore` to avoid committing generated files. Only `docs.html` (the source file) should be committed to your repository.
+
+### `packer verify`
+
+Comprehensive package verification before publishing. This command builds, packs, and thoroughly tests your package to ensure it's ready for npm.
+
+```bash
+packer verify
+```
+
+This command:
+
+1. Builds the package (`npm run build`)
+2. Packs it (`npm pack`)
+3. Extracts and verifies the tarball structure
+4. Checks for required files (package.json, README.md, LICENSE, dist files)
+5. Analyzes bundle size
+6. Verifies no `react-jsx-runtime` is bundled (critical for React libraries)
+7. Cleans up temporary files
+
+**Configuration Options:**
+
+```bash
+packer verify --dist=build
+```
+
+Available parameters:
+
+- `--dist` - Build directory to verify (default: `dist`)
+
+This is the most thorough test and should be run before publishing to npm.
+
+### `packer preview`
+
+Start a local HTTP server to preview your documentation in a browser.
+
+```bash
+packer preview
+```
+
+**Configuration Options:**
+
+```bash
+packer preview --host=localhost --port=3000 --docs-dir=public
+```
+
+Available parameters:
+
+- `--host` - Server host (default: `127.0.0.1`)
+- `--port` - Server port (default: `8080`)
+- `--docs-dir` - Documentation directory to serve (default: `docs`)
+
+Default behavior:
+
+- Serves files from project root
+- Default URL: `http://127.0.0.1:8080/`
+- Serves `docs/index.html` at root path
+- Press `Ctrl+C` to stop the server
+
+## Project Structure
+
+This tool expects your React library project to follow this structure:
+
+```
+your-project/
+├── dist/              # Built package output (gitignored)
+├── docs/              # Generated docs for Pages hosting (gitignored)
+├── docs.html          # Source HTML file for documentation
+├── src/               # Source files
+├── package.json
+└── package-lock.json
+```
+
+**Important**: Add the following to your `.gitignore`:
+
+```gitignore
+# Build outputs
+dist/
+
+# Docs folder (generated from docs.html)
+docs/
+```
+
+This keeps your repository clean by only tracking the source `docs.html` file, not the generated `docs/` folder.
+
+## Typical Workflow
+
+Here's a typical release workflow using packer:
+
+```bash
+# 1. Verify package (builds, packs, and tests)
+packer verify
+
+# 2. Preview docs in browser (optional)
+packer preview
+
+# 3. Sync documentation
+packer docs
+
+# 4. Bump version
+packer bump
+
+# 5. Publish to npm
+npm publish
+```
+
+Or combine steps in a release script:
+
+```json
+{
+  "scripts": {
+    "release": "packer verify && packer docs && packer bump && npm publish"
+  }
+}
+```
+
+## Requirements
+
+- Node.js >= 18.0.0
+- npm or yarn
+- Standard React library build setup (TypeScript + Vite recommended)
+
+## Examples
+
+See these projects using `@gozenc/packer`:
+
+- [@gozenc/react-tooltip](https://github.com/gozenc/react-tooltip)
+- [@gozenc/react-dark-mode-toggle](https://github.com/gozenc/react-dark-mode-toggle)
+
+## License
+
+MIT © Fatih Gözenç
+
+## Contributing
+
+Issues and pull requests are welcome! Please visit the [GitHub repository](https://github.com/gozenc/package-builder).

package/bin/packer.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { readFile } from "fs/promises";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const commands = {
+  bump: {
+    description: "Bump package version",
+    file: "bump.js",
+  },
+  docs: {
+    description: "Sync docs from docs.html to docs/",
+    file: "docs.js",
+  },
+  verify: {
+    description: "Verify package before publishing (build, pack, and test)",
+    file: "verify.js",
+  },
+  preview: {
+    description: "Start a local server to preview docs in browser",
+    file: "preview.js",
+  },
+};
+
+async function showHelp() {
+  const packageJson = JSON.parse(
+    await readFile(join(__dirname, "..", "package.json"), "utf8")
+  );
+
+  console.log(`
+${packageJson.name} v${packageJson.version}
+${packageJson.description}
+
+Usage: packer <command> [options]
+
+Commands:
+${Object.entries(commands)
+  .map(([cmd, { description }]) => `  ${cmd.padEnd(20)} ${description}`)
+  .join("\n")}
+
+  help                 Show this help message
+
+Examples:
+  packer bump                              # Interactive version bump
+  packer bump 1.2.3                        # Bump to specific version
+  packer docs                              # Sync documentation
+  packer docs --dist=<dir> --docs-dir=<dir>
+  packer verify                            # Verify package before publishing
+  packer verify --dist=<dir>
+  packer preview                           # Preview docs in browser
+  packer preview --host=<host> --port=<port>
+
+Configuration Options:
+  --dist=<dir>         Build directory (default: dist)
+  --host=<host>        Server host (default: 127.0.0.1)
+  --port=<port>        Server port (default: 8080)
+  --docs-dir=<dir>     Documentation directory (default: docs)
+  --docs-file=<file>   Source HTML file (default: docs.html)
+
+For more information, visit: ${
+    packageJson.repository?.url || packageJson.homepage || ""
+  }
+`);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (
+    !command ||
+    command === "help" ||
+    command === "--help" ||
+    command === "-h"
+  ) {
+    await showHelp();
+    return;
+  }
+
+  if (command === "version" || command === "--version" || command === "-v") {
+    const packageJson = JSON.parse(
+      await readFile(join(__dirname, "..", "package.json"), "utf8")
+    );
+    console.log(packageJson.version);
+    return;
+  }
+
+  const commandConfig = commands[command];
+
+  if (!commandConfig) {
+    console.error(`❌ Unknown command: ${command}`);
+    console.log(`Run 'packer help' to see available commands.`);
+    process.exitCode = 1;
+    return;
+  }
+
+  try {
+    const commandPath = join(__dirname, "..", "lib", commandConfig.file);
+    const commandModule = await import(commandPath);
+
+    // If the module has a default export, call it with remaining args
+    if (commandModule.default) {
+      // Pass remaining arguments (after the command) to the module
+      const commandArgs = args.slice(1);
+      await commandModule.default(...commandArgs);
+    }
+  } catch (error) {
+    console.error(`❌ Failed to execute command '${command}':`, error.message);
+    process.exitCode = 1;
+  }
+}
+
+main().catch((error) => {
+  console.error("❌ Unexpected error:", error);
+  process.exitCode = 1;
+});

package/lib/bump.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import readline from "readline";
+
+// Use process.cwd() to get the project directory where the command is run
+const projectDir = process.cwd();
+
+function bumpPatch(version) {
+  const [major, minor, patch = "0"] = version.split(".");
+  const numericPatch = Number.parseInt(patch, 10);
+  if (Number.isNaN(numericPatch)) {
+    return version;
+  }
+  return `${major}.${minor}.${numericPatch + 1}`;
+}
+
+function isValidVersion(value) {
+  return /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:[-+][0-9A-Za-z-.]+)?$/.test(
+    value
+  );
+}
+
+function prompt(question, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    const fullQuestion = defaultValue
+      ? `${question} (${defaultValue}): `
+      : `${question}: `;
+    rl.question(fullQuestion, (answer) => {
+      rl.close();
+      const value = answer.trim();
+      resolve(value || defaultValue || "");
+    });
+  });
+}
+
+async function updateJSONFile(relativePath, updater) {
+  const filePath = join(projectDir, relativePath);
+  const original = await readFile(filePath, "utf8");
+  const data = JSON.parse(original);
+  const updated = await updater(data);
+  await writeFile(filePath, `${JSON.stringify(updated, null, 2)}\n`);
+}
+
+async function updateTextFile(relativePath, replacements) {
+  const filePath = join(projectDir, relativePath);
+  const original = await readFile(filePath, "utf8");
+  let updated = original;
+
+  for (const { from, to, description } of replacements) {
+    const next = updated.replace(from, to);
+    if (next === updated) {
+      console.warn(`⚠️  No match found for ${description} in ${relativePath}`);
+    }
+    updated = next;
+  }
+
+  if (updated !== original) {
+    await writeFile(filePath, updated);
+  }
+}
+
+async function main(versionArg) {
+  console.log("🔍 Reading package metadata...");
+
+  const packageJsonPath = join(projectDir, "package.json");
+  const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+
+  const currentVersion = packageJson.version;
+  const suggestedVersion = bumpPatch(currentVersion);
+
+  let targetVersion = versionArg?.trim();
+
+  if (!targetVersion) {
+    targetVersion = await prompt(
+      `Current version is ${currentVersion}. Enter new version`,
+      suggestedVersion
+    );
+  }
+
+  if (!targetVersion) {
+    console.error("❌ No version provided. Aborting.");
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!isValidVersion(targetVersion)) {
+    console.error(`❌ ${targetVersion} is not a valid semver string.`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (targetVersion === currentVersion) {
+    console.error("❌ New version matches the current version. Nothing to do.");
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(`🚀 Updating version to ${targetVersion}...`);
+
+  await updateJSONFile("package.json", async (data) => ({
+    ...data,
+    version: targetVersion,
+  }));
+
+  await updateJSONFile("package-lock.json", async (data) => {
+    const updated = { ...data, version: targetVersion };
+    if (updated.packages?.[""]) {
+      updated.packages[""] = {
+        ...updated.packages[""],
+        version: targetVersion,
+      };
+    }
+    return updated;
+  });
+
+  const softwareVersionFrom = `"softwareVersion": "${currentVersion}"`;
+  const softwareVersionTo = `"softwareVersion": "${targetVersion}"`;
+
+  // Try to update docs.html if it exists
+  try {
+    await updateTextFile("docs.html", [
+      {
+        from: softwareVersionFrom,
+        to: softwareVersionTo,
+        description: "softwareVersion JSON-LD entry",
+      },
+    ]);
+  } catch (error) {
+    console.warn("⚠️  docs.html not found.");
+    // File doesn't exist or doesn't have softwareVersion, skip silently
+  }
+
+  // Try to update docs/index.html if it exists
+  try {
+    await updateTextFile("docs/index.html", [
+      {
+        from: softwareVersionFrom,
+        to: softwareVersionTo,
+        description: "softwareVersion JSON-LD entry",
+      },
+    ]);
+  } catch (error) {
+    console.warn("⚠️  docs/index.html not found.");
+    // File doesn't exist or doesn't have softwareVersion, skip silently
+  }
+
+  console.log("✅ Version bump complete.");
+  console.log("🔢 Previous version:", currentVersion);
+  console.log("✨ New version:", targetVersion);
+  console.log(
+    "📦 Remember to update the changelog and run npm publish when ready."
+  );
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error("❌ Failed to bump version:", error);
+    process.exitCode = 1;
+  });
+}
+
+export default main;

package/lib/config.js

@@ -0,0 +1,46 @@
+/**
+ * Parse command-line arguments and return configuration
+ */
+export function parseArgs(args = []) {
+  const config = {
+    // Default values
+    dist: "dist",
+    host: "127.0.0.1",
+    port: 8080,
+    docsDir: "docs",
+    docsFile: "docs.html",
+  };
+
+  for (const arg of args) {
+    if (arg.startsWith("--")) {
+      const [key, value] = arg.slice(2).split("=");
+
+      // Convert kebab-case to camelCase
+      const camelKey = key.replace(/-([a-z])/g, (_, letter) =>
+        letter.toUpperCase()
+      );
+
+      // Parse port as number
+      if (camelKey === "port") {
+        config[camelKey] = parseInt(value, 10);
+      } else if (value !== undefined) {
+        config[camelKey] = value;
+      }
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Get default configuration
+ */
+export function getDefaults() {
+  return {
+    dist: "dist",
+    host: "127.0.0.1",
+    port: 8080,
+    docsDir: "docs",
+    docsFile: "docs.html",
+  };
+}

package/lib/docs.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { mkdir, readFile, writeFile, rm, cp } from "fs/promises";
+import path from "path";
+import { parseArgs } from "./config.js";
+
+async function run(...args) {
+  // Parse configuration from arguments
+  const config = parseArgs(args);
+
+  // Use process.cwd() to get the project directory where the command is run
+  const projectDir = process.cwd();
+  const htmlSource = path.join(projectDir, config.docsFile);
+  const distSource = path.join(projectDir, config.dist);
+  const docsDir = path.join(projectDir, config.docsDir);
+  const docsDist = path.join(docsDir, config.dist);
+  const docsIndex = path.join(docsDir, "index.html");
+
+  // Create docs directory
+  await mkdir(docsDir, { recursive: true });
+
+  // Copy docs file to docs/index.html
+  const html = await readFile(htmlSource, "utf8");
+  await writeFile(docsIndex, html, "utf8");
+
+  // Remove old dist folder in docs and copy fresh one
+  await rm(docsDist, { recursive: true, force: true });
+  await cp(distSource, docsDist, { recursive: true });
+
+  console.log("✅ Docs synced successfully!");
+  console.log(`   ${config.docsFile} -> ${config.docsDir}/index.html`);
+  console.log(`   ${config.dist}/ -> ${config.docsDir}/${config.dist}/`);
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  run().catch((error) => {
+    console.error("Failed to sync docs:", error);
+    process.exitCode = 1;
+  });
+}
+
+export default run;

package/lib/preview.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+/**
+ * Simple Node.js static file server for testing
+ */
+
+import { createServer } from "http";
+import { readFile, stat } from "fs/promises";
+import { join, extname } from "path";
+import { parseArgs } from "./config.js";
+
+const mimeTypes = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+};
+
+function startServer(...args) {
+  // Parse configuration from arguments
+  const config = parseArgs(args);
+
+  // Use process.cwd() to get the project directory where the command is run
+  const projectDir = process.cwd();
+
+  const server = createServer(async (req, res) => {
+    try {
+      let filePath =
+        req.url === "/" ? `/${config.docsDir}/index.html` : req.url;
+      filePath = join(projectDir, filePath);
+
+      const stats = await stat(filePath);
+
+      if (stats.isFile()) {
+        const ext = extname(filePath);
+        const contentType = mimeTypes[ext] || "application/octet-stream";
+
+        res.writeHead(200, {
+          "Content-Type": contentType,
+          "Access-Control-Allow-Origin": "*",
+        });
+
+        const content = await readFile(filePath);
+        res.end(content);
+      } else {
+        res.writeHead(404);
+        res.end("File not found");
+      }
+    } catch (error) {
+      res.writeHead(404);
+      res.end("File not found");
+    }
+  });
+
+  server.listen(config.port, config.host, () => {
+    console.log(`🚀 Preview at http://${config.host}:${config.port}/`);
+    console.log(`📁 Serving from: ${projectDir}`);
+    console.log(`📄 Root: ${config.docsDir}/index.html`);
+  });
+
+  // Handle graceful shutdown
+  process.on("SIGINT", () => {
+    console.log("\n👋 Shutting down server...");
+    server.close(() => {
+      process.exit(0);
+    });
+  });
+
+  return server;
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  startServer();
+}
+
+export default startServer;

package/lib/verify.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * Test the built package locally using npm pack
+ */
+
+import { execSync } from "child_process";
+import { readFileSync, existsSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { parseArgs } from "./config.js";
+
+async function testLocal(...args) {
+  // Parse configuration from arguments
+  const config = parseArgs(args);
+
+  // Use process.cwd() to get the project directory where the command is run
+  const projectDir = process.cwd();
+
+  console.log("🧪 Testing built package locally...\n");
+
+  try {
+    // 1. Build the package
+    console.log("📦 Building package...");
+    execSync("npm run build", { stdio: "inherit", cwd: projectDir });
+
+    // 2. Pack the package
+    console.log("\n📦 Packing package...");
+    const packResult = execSync("npm pack", {
+      encoding: "utf8",
+      cwd: projectDir,
+    });
+    const tarballName = packResult.trim();
+
+    // 3. Create test directory
+    const testDir = join(projectDir, "test-package-temp");
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+    mkdirSync(testDir);
+
+    // 4. Extract and test
+    console.log("\n📂 Extracting package...");
+    execSync(`tar -xzf ${tarballName} -C ${testDir}`, {
+      stdio: "inherit",
+      cwd: projectDir,
+    });
+
+    const packageDir = join(testDir, "package");
+
+    // 5. Verify package structure
+    console.log("\n🔍 Verifying package structure...");
+
+    const requiredFiles = [
+      "package.json",
+      "README.md",
+      "LICENSE",
+      `${config.dist}/index.js`,
+      `${config.dist}/index.d.ts`,
+    ];
+
+    let allFilesExist = true;
+    for (const file of requiredFiles) {
+      const filePath = join(packageDir, file);
+      if (existsSync(filePath)) {
+        console.log(`✅ ${file}`);
+      } else {
+        console.log(`❌ ${file} - MISSING`);
+        allFilesExist = false;
+      }
+    }
+
+    // 6. Check package.json
+    const packageJson = JSON.parse(
+      readFileSync(join(packageDir, "package.json"), "utf8")
+    );
+    console.log(`\n📋 Package: ${packageJson.name}@${packageJson.version}`);
+    console.log(`📄 Main: ${packageJson.main}`);
+    console.log(`📝 Types: ${packageJson.types}`);
+
+    // 7. Check bundle size
+    const bundleContent = readFileSync(
+      join(packageDir, config.dist, "index.js"),
+      "utf8"
+    );
+    const bundleSize = (bundleContent.length / 1024).toFixed(2);
+    console.log(`📊 Bundle size: ${bundleSize} KB`);
+
+    // 8. Check for react-jsx-runtime
+    const hasJsxRuntime = bundleContent.includes("react-jsx-runtime");
+    console.log(
+      `🔍 Contains react-jsx-runtime: ${hasJsxRuntime ? "❌ YES" : "✅ NO"}`
+    );
+
+    // 9. Cleanup
+    console.log("\n🧹 Cleaning up...");
+    rmSync(testDir, { recursive: true });
+    rmSync(tarballName);
+
+    if (allFilesExist && !hasJsxRuntime) {
+      console.log("\n🎉 Package test PASSED! Ready for publishing.");
+      console.log("\nNext steps:");
+      console.log("1. npm login");
+      console.log("2. npm publish");
+    } else {
+      console.log("\n❌ Package test FAILED. Please fix the issues above.");
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("❌ Test failed:", error.message);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  testLocal();
+}
+
+export default testLocal;

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@gozenc/packer",
+  "version": "1.0.0",
+  "description": "Collection of package builder scripts for React libraries.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "packer": "./bin/packer.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "npm",
+    "packer",
+    "package",
+    "builder",
+    "react",
+    "library",
+    "node",
+    "cli",
+    "tools",
+    "version",
+    "bump",
+    "docs",
+    "testing"
+  ],
+  "author": "Fatih Gözenç",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gozenc/packer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gozenc/packer/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}