screw-up 0.7.1 → 0.9.1

package/README.md

@@ -48,6 +48,8 @@ To insert banner header each bundled source files (`dist/index.js` and etc.):
 * Flexible output: Specify exactly which keys to include and in what order.
 * Nested object support: Handles nested objects like `author.name`, `repository.url`.
 * Customizable: Choose which metadata fields to include in your banner.
+* TypeScript metadata generation: Automatically generates TypeScript files with metadata constants for use in your source code.
+* Supported pack/publish CLI interface. When publishing using this feature, the package is generated after applying the above processing to `package.json`.
 
 ## Installation
 
@@ -155,6 +157,66 @@ Results in:
  */
 ```
 
+### TypeScript Metadata Generation
+
+The plugin can generate TypeScript files containing metadata constants that you can import and use in your source code:
+
+```typescript
+import { defineConfig } from 'vite';
+import screwUp from 'screw-up';
+
+export default defineConfig({
+  plugins: [
+    screwUp({
+      outputMetadataFile: true, // Enable metadata file generation
+      outputMetadataFilePath: 'src/generated/packageMetadata.ts', // Custom path (optional)
+      outputMetadataKeys: ['name', 'version', 'description', 'author', 'license'] // Keys to include
+    })
+  ],
+  build: {
+    lib: {
+      entry: 'src/index.ts',
+      name: 'MyLibrary',
+      fileName: 'index'
+    }
+  }
+});
+```
+
+This generates `src/generated/packageMetadata.ts` with sanitized TypeScript constants:
+
+```typescript
+// This file is auto-generated by screw-up plugin
+// Do not edit manually
+
+export const name = "my-awesome-library";
+export const version = "2.1.0";
+export const description = "An awesome TypeScript library";
+export const author = "Jane Developer <jane@example.com>";
+export const license = "Apache-2.0";
+```
+
+You can then import and use these constants in your source code:
+
+```typescript
+import { name, version } from './generated/packageMetadata.js';
+
+console.log(`${name} v${version}`);
+// Output: my-awesome-library v2.1.0
+
+export function getLibraryInfo() {
+  return { name, version };
+}
+```
+
+#### Key Sanitization
+
+Keys with special characters are automatically sanitized to valid TypeScript identifiers:
+
+- `repository.url` → `repository_url`
+- `custom-key` → `custom_key`
+- `123invalid` → `_123invalid`
+
 ----
 
 ## Advanced Usage
@@ -234,6 +296,84 @@ The plugin automatically detects and supports:
 
 ----
 
+## CLI Usage
+
+The `screw-up` package includes a command-line interface for packaging and publishing your projects.
+
+### Pack Command
+
+Create a tar archive of your project:
+
+```bash
+# Pack current directory
+screw-up pack
+
+# Pack specific directory
+screw-up pack ./my-project
+
+# Pack to specific output directory
+screw-up pack --pack-destination ./dist
+```
+
+The pack command:
+
+- Automatically reads `package.json` for metadata and file inclusion rules
+- Respects the `files` field in your `package.json`
+- Supports workspace inheritance (inherits metadata from parent packages)
+- Creates a compressed `.tgz` archive with format: `{name}-{version}.tgz`
+
+### Publish Command
+
+Publish your project to registry server:
+
+```bash
+# Publish current directory (creates archive and publishes)
+screw-up publish
+
+# Publish specific directory
+screw-up publish ./my-project
+
+# Publish existing tarball
+screw-up publish package.tgz
+
+# Publish with npm options (all npm publish options are supported)
+screw-up publish --dry-run --tag beta --access public
+```
+
+The publish command:
+
+- Supports all `npm publish` options transparently
+- Can publish from directory (automatically creates archive) or existing tarball
+- Handles workspace packages with proper metadata inheritance
+- Uses the same packaging logic as the pack command
+
+### Examples
+
+```bash
+# Build and publish with dry run
+screw-up publish --dry-run
+
+# Publish to beta channel
+screw-up publish --tag beta
+
+# Publish scoped package as public
+screw-up publish --access public
+
+# Pack to custom directory then publish
+screw-up pack --pack-destination ./release
+screw-up publish ./release/my-package-1.0.0.tgz
+```
+
+For help with any command:
+
+```bash
+screw-up --help
+screw-up pack --help
+screw-up publish --help
+```
+
+----
+
 ## License
 
-Under MIT
+Under MIT

package/dist/cli-internal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Pack assets into a tar archive
+ * @param targetDir - Target directory to pack
+ * @param outputDir - Output directory to write the tarball
+ * @returns Package metadata (package.json) or undefined if failed
+ */
+export declare const packAssets: (targetDir: string, outputDir: string) => Promise<any>;
+export interface ParsedArgs {
+    command?: string;
+    positional: string[];
+    options: Record<string, string | boolean>;
+}
+export declare const parseArgs: (argv: string[]) => ParsedArgs;
+//# sourceMappingURL=cli-internal.d.ts.map

package/dist/cli-internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-internal.d.ts","sourceRoot":"","sources":["../src/cli-internal.ts"],"names":[],"mappings":"AAyCA;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAU,WAAW,MAAM,EAAE,WAAW,MAAM,KAAI,OAAO,CAAC,GAAG,CA2EnF,CAAC;AAIF,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC;CAC3C;AAED,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,EAAE,KAAG,UAoE1C,CAAC"}

package/dist/cli.cjs

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+"use strict";
+const path = require("path");
+const fs = require("fs");
+const promises = require("fs/promises");
+const child_process = require("child_process");
+const glob = require("glob");
+const internal = require("./internal-BJ2gdqpB.cjs");
+const tar = require("tar-stream");
+const zlib = require("zlib");
+const addPackContentEntry = async (pack, name, content) => {
+  pack.entry({
+    name,
+    type: "file",
+    mode: 420,
+    mtime: /* @__PURE__ */ new Date(),
+    size: Buffer.byteLength(content, "utf8")
+  }, content);
+};
+const addPackFileEntry = async (pack, baseDir, path$1, stat) => {
+  const writer = pack.entry({
+    name: path$1,
+    mode: stat.mode,
+    mtime: stat.mtime,
+    size: stat.size
+  });
+  const stream = fs.createReadStream(path.resolve(baseDir, path$1));
+  stream.pipe(writer);
+  return new Promise((resolve2, reject) => {
+    stream.on("end", resolve2);
+    stream.on("error", reject);
+    writer.on("error", reject);
+  });
+};
+const packAssets = async (targetDir, outputDir) => {
+  var _a, _b, _c, _d;
+  if (!fs.existsSync(targetDir)) {
+    return void 0;
+  }
+  let resolvedPackageJson;
+  try {
+    resolvedPackageJson = await internal.resolveRawPackageJson(targetDir);
+  } catch (error) {
+    return void 0;
+  }
+  if (resolvedPackageJson == null ? void 0 : resolvedPackageJson.private) {
+    return void 0;
+  }
+  const outputFileName = `${(_b = (_a = resolvedPackageJson == null ? void 0 : resolvedPackageJson.name) == null ? void 0 : _a.replace("/", "-")) != null ? _b : "package"}-${(_c = resolvedPackageJson == null ? void 0 : resolvedPackageJson.version) != null ? _c : "0.0.0"}.tgz`;
+  const pack = tar.pack();
+  try {
+    const packageJsonContent = JSON.stringify(resolvedPackageJson, null, 2);
+    await addPackContentEntry(pack, "package.json", packageJsonContent);
+    const distributionFileGlobs = (_d = resolvedPackageJson == null ? void 0 : resolvedPackageJson.files) != null ? _d : ["**/*"];
+    const packingFilePaths = distributionFileGlobs.map((fg) => glob.glob.sync(fg, { cwd: targetDir })).flat();
+    for (const packingFilePath of packingFilePaths) {
+      const fullPath = path.resolve(targetDir, packingFilePath);
+      const stat = await promises.lstat(fullPath);
+      if (stat.isFile() && packingFilePath !== "package.json") {
+        await addPackFileEntry(pack, targetDir, packingFilePath, stat);
+      }
+    }
+    pack.finalize();
+    if (!fs.existsSync(outputDir)) {
+      await promises.mkdir(outputDir, { recursive: true });
+    }
+    const outputFile = path.resolve(outputDir, outputFileName);
+    const outputStream = fs.createWriteStream(outputFile);
+    const gzip = zlib.createGzip();
+    await new Promise((resolve2, reject) => {
+      pack.pipe(gzip).pipe(outputStream);
+      outputStream.on("finish", () => resolve2());
+      outputStream.on("error", reject);
+      pack.on("error", reject);
+      gzip.on("error", reject);
+    });
+  } finally {
+    pack.destroy();
+  }
+  return resolvedPackageJson;
+};
+const parseArgs = (argv) => {
+  const args = argv.slice(2);
+  const result = {
+    positional: [],
+    options: {}
+  };
+  if (args.length === 0) {
+    return result;
+  }
+  if (args[0].startsWith("-")) {
+    let i2 = 0;
+    while (i2 < args.length) {
+      const arg = args[i2];
+      if (arg.startsWith("--")) {
+        const optionName = arg.slice(2);
+        const nextArg = args[i2 + 1];
+        if (nextArg && !nextArg.startsWith("-")) {
+          result.options[optionName] = nextArg;
+          i2 += 2;
+        } else {
+          result.options[optionName] = true;
+          i2 += 1;
+        }
+      } else if (arg.startsWith("-")) {
+        const optionName = arg.slice(1);
+        result.options[optionName] = true;
+        i2 += 1;
+      } else {
+        result.positional.push(arg);
+        i2 += 1;
+      }
+    }
+    return result;
+  }
+  result.command = args[0];
+  let i = 1;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const optionName = arg.slice(2);
+      const nextArg = args[i + 1];
+      if (nextArg && !nextArg.startsWith("-")) {
+        result.options[optionName] = nextArg;
+        i += 2;
+      } else {
+        result.options[optionName] = true;
+        i += 1;
+      }
+    } else if (arg.startsWith("-")) {
+      const optionName = arg.slice(1);
+      result.options[optionName] = true;
+      i += 1;
+    } else {
+      result.positional.push(arg);
+      i += 1;
+    }
+  }
+  return result;
+};
+const showHelp = () => {
+  console.log(`screw-up - Easy package metadata inserter CLI [${"0.9.1"}]
+Copyright (c) ${"Kouji Matsui (@kekyo@mi.kekyo.net)"}
+Repository: ${"https://github.com/kekyo/screw-up.git"}
+License: ${"MIT"}
+
+Usage: screw-up <command> [options]
+
+Commands:
+  pack [directory]              Pack the project into a tar archive
+  publish [directory|package.tgz]  Publish the project
+
+Options:
+  -h, --help                    Show help
+
+Pack Options:
+  --pack-destination <path>     Directory to write the tarball
+
+Publish Options:
+  All npm publish options are supported (e.g., --dry-run, --tag, --access, --registry)
+
+Examples:
+  screw-up pack                          # Pack current directory
+  screw-up pack ./my-project             # Pack specific directory
+  screw-up pack --pack-destination ./dist # Pack to specific output directory
+  screw-up publish                       # Publish current directory
+  screw-up publish ./my-project          # Publish specific directory
+  screw-up publish package.tgz           # Publish existing tarball
+  screw-up publish --dry-run --tag beta  # Publish with npm options
+`);
+};
+const showPackHelp = () => {
+  console.log(`Usage: screw-up pack [options] [directory]
+
+Pack the project into a tar archive
+
+Arguments:
+  directory                     Directory to pack (default: current directory)
+
+Options:
+  --pack-destination <path>     Directory to write the tarball
+  -h, --help                    Show help for pack command
+`);
+};
+const showPublishHelp = () => {
+  console.log(`Usage: screw-up publish [options] [directory|package.tgz]
+
+Publish the project
+
+Arguments:
+  directory|package.tgz         Directory to pack and publish, or existing tarball to publish
+
+Options:
+  All npm publish options are supported, including:
+  --dry-run                     Perform a dry run
+  --tag <tag>                   Tag for the published version
+  --access <access>             Access level (public or restricted)
+  --registry <registry>         Registry URL
+  -h, --help                    Show help for publish command
+
+Examples:
+  screw-up publish                       # Publish current directory
+  screw-up publish ./my-project          # Publish specific directory
+  screw-up publish package.tgz           # Publish existing tarball
+  screw-up publish --dry-run --tag beta  # Publish with options
+`);
+};
+const packCommand = async (args) => {
+  if (args.options.help || args.options.h) {
+    showPackHelp();
+    return;
+  }
+  const directory = args.positional[0];
+  const packDestination = args.options["pack-destination"];
+  const targetDir = path.resolve(directory != null ? directory : process.cwd());
+  const outputDir = packDestination ? path.resolve(packDestination) : process.cwd();
+  console.log(`[screw-up/cli]: pack: Creating archive of ${targetDir}...`);
+  try {
+    const metadata = await packAssets(targetDir, outputDir);
+    if (metadata) {
+      console.log(`[screw-up/cli]: pack: Archive created successfully: ${outputDir}`);
+    } else {
+      console.error(`[screw-up/cli]: pack: Unable to find any files to pack: ${targetDir}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("[screw-up/cli]: pack: Failed to create archive:", error);
+    process.exit(1);
+  }
+};
+const publishCommand = async (args) => {
+  if (args.options.help || args.options.h) {
+    showPublishHelp();
+    return;
+  }
+  const runNpmPublish = async (tarballPath, npmOptions2 = []) => {
+    console.log(`[screw-up/cli]: publish: Publishing ${tarballPath} to npm...`);
+    const publishArgs = ["publish", tarballPath, ...npmOptions2];
+    if (process.env.SCREW_UP_TEST_MODE === "true") {
+      console.log(`[screw-up/cli]: TEST_MODE: Would execute: npm ${publishArgs.join(" ")}`);
+      console.log(`[screw-up/cli]: TEST_MODE: Tarball path: ${tarballPath}`);
+      console.log(`[screw-up/cli]: TEST_MODE: Options: ${npmOptions2.join(" ")}`);
+      console.log(`[screw-up/cli]: publish: Successfully published ${tarballPath}`);
+      return;
+    }
+    const npmProcess = child_process.spawn("npm", publishArgs, { stdio: "inherit" });
+    return new Promise((resolve2, reject) => {
+      npmProcess.on("close", (code) => {
+        if (code === 0) {
+          console.log(`[screw-up/cli]: publish: Successfully published ${tarballPath}`);
+          resolve2();
+        } else {
+          reject(new Error(`npm publish failed with exit code ${code}`));
+        }
+      });
+      npmProcess.on("error", reject);
+    });
+  };
+  const path$1 = args.positional[0];
+  const npmOptions = [];
+  Object.entries(args.options).forEach(([key, value]) => {
+    if (key === "help" || key === "h") return;
+    if (value === true) {
+      npmOptions.push(`--${key}`);
+    } else {
+      npmOptions.push(`--${key}`, value);
+    }
+  });
+  try {
+    if (!path$1) {
+      const targetDir = process.cwd();
+      const outputDir = await promises.mkdtemp("screw-up-publish-");
+      console.log(`[screw-up/cli]: publish: Creating archive of ${targetDir}...`);
+      try {
+        const metadata = await packAssets(targetDir, outputDir);
+        if (metadata) {
+          const archiveName = `${metadata.name}-${metadata.version}.tgz`;
+          const archivePath = path.join(outputDir, archiveName);
+          await runNpmPublish(archivePath, npmOptions);
+        } else {
+          console.error(`[screw-up/cli]: publish: Unable to find any files to pack: ${targetDir}`);
+          process.exit(1);
+        }
+      } finally {
+        await promises.rm(outputDir, { recursive: true, force: true });
+      }
+    } else if (fs.existsSync(path$1)) {
+      const pathStat = await promises.stat(path$1);
+      if (pathStat.isFile() && (path$1.endsWith(".tgz") || path$1.endsWith(".tar.gz"))) {
+        await runNpmPublish(path.resolve(path$1), npmOptions);
+      } else if (pathStat.isDirectory()) {
+        const targetDir = path.resolve(path$1);
+        const outputDir = await promises.mkdtemp("screw-up-publish-");
+        console.log(`[screw-up/cli]: publish: Creating archive of ${targetDir}...`);
+        try {
+          const metadata = await packAssets(targetDir, outputDir);
+          if (metadata) {
+            const archiveName = `${metadata.name}-${metadata.version}.tgz`;
+            const archivePath = path.join(outputDir, archiveName);
+            await runNpmPublish(archivePath, npmOptions);
+          } else {
+            console.error(`[screw-up/cli]: publish: Unable to find any files to pack: ${targetDir}`);
+            process.exit(1);
+          }
+        } finally {
+          await promises.rm(outputDir, { recursive: true, force: true });
+        }
+      } else {
+        console.error(`[screw-up/cli]: publish: Invalid path - must be a directory or .tgz/.tar.gz file: ${path$1}`);
+        process.exit(1);
+      }
+    } else {
+      console.error(`[screw-up/cli]: publish: Path does not exist: ${path$1}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("[screw-up/cli]: publish: Failed to publish:", error);
+    process.exit(1);
+  }
+};
+const main = async () => {
+  const args = parseArgs(process.argv);
+  if (args.options.help || args.options.h || !args.command || args.command === "help" || args.command === "--help") {
+    showHelp();
+    return;
+  }
+  switch (args.command) {
+    case "pack":
+      await packCommand(args);
+      break;
+    case "publish":
+      await publishCommand(args);
+      break;
+    default:
+      console.error(`Unknown command: ${args.command}`);
+      console.error('Run "screw-up --help" for usage information.');
+      process.exit(1);
+  }
+};
+main().catch((error) => {
+  console.error("CLI error:", error);
+  process.exit(1);
+});

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}