@olegkuibar/plunk 0.2.0-canary.04ff96f

package/dist/publish-UXCLPNM6.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  publish
+} from "./chunk-4O2QOKVO.mjs";
+import {
+  errorWithSuggestion
+} from "./chunk-S4HJSJ32.mjs";
+import "./chunk-W3C72UKC.mjs";
+import {
+  Timer
+} from "./chunk-XZK5T4GK.mjs";
+import "./chunk-PUSXMPOF.mjs";
+import "./chunk-EDUXIQ5W.mjs";
+import {
+  output,
+  suppressHumanOutput
+} from "./chunk-ZOYNYK5Y.mjs";
+import {
+  defineCommand
+} from "./chunk-CSMZ6DZA.mjs";
+import "./chunk-HKNM3UWU.mjs";
+import {
+  verbose
+} from "./chunk-I6SN7BBN.mjs";
+import "./chunk-KYDBD2KQ.mjs";
+
+// src/commands/publish.ts
+import { resolve } from "path";
+var publish_default = defineCommand({
+  meta: {
+    name: "publish",
+    description: "Publish current package to the plunk store"
+  },
+  args: {
+    dir: {
+      type: "positional",
+      description: "Package directory (default: current directory)",
+      required: false
+    },
+    private: {
+      type: "boolean",
+      description: "Allow publishing private packages",
+      default: false
+    }
+  },
+  async run({ args }) {
+    suppressHumanOutput();
+    const timer = new Timer();
+    const dir = resolve(args.dir || ".");
+    verbose(`[publish] Publishing from ${dir}`);
+    try {
+      const result = await publish(dir, { allowPrivate: args.private });
+      output({ ...result, elapsed: timer.elapsedMs() });
+    } catch (err) {
+      errorWithSuggestion(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  }
+});
+export {
+  publish_default as default
+};

package/dist/push-JI6HGCFG.mjs

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  startWatcher
+} from "./chunk-LKQINKH4.mjs";
+import {
+  inject
+} from "./chunk-CZM4TNAI.mjs";
+import {
+  detectBuildCommand
+} from "./chunk-XMIZ7OUZ.mjs";
+import {
+  detectPackageManager
+} from "./chunk-34UXZ622.mjs";
+import {
+  addLink,
+  getConsumers,
+  getLink
+} from "./chunk-GAAB2TLH.mjs";
+import {
+  publish
+} from "./chunk-4O2QOKVO.mjs";
+import {
+  errorWithSuggestion
+} from "./chunk-S4HJSJ32.mjs";
+import {
+  getStoreEntry
+} from "./chunk-W3C72UKC.mjs";
+import {
+  Timer
+} from "./chunk-XZK5T4GK.mjs";
+import "./chunk-PUSXMPOF.mjs";
+import "./chunk-EDUXIQ5W.mjs";
+import {
+  output,
+  suppressHumanOutput
+} from "./chunk-ZOYNYK5Y.mjs";
+import {
+  defineCommand
+} from "./chunk-CSMZ6DZA.mjs";
+import {
+  pLimit
+} from "./chunk-HKNM3UWU.mjs";
+import {
+  consola,
+  verbose
+} from "./chunk-I6SN7BBN.mjs";
+import "./chunk-KYDBD2KQ.mjs";
+
+// src/commands/push.ts
+import { readFile } from "fs/promises";
+import { resolve, join } from "path";
+var consumerLimit = pLimit(4);
+var push_default = defineCommand({
+  meta: {
+    name: "push",
+    description: "Publish and push to all consumers. Use --watch for continuous mode."
+  },
+  args: {
+    watch: {
+      type: "boolean",
+      description: "Watch for changes and auto-push",
+      default: false
+    },
+    build: {
+      type: "string",
+      description: "Build command to run before publishing (watch mode)"
+    },
+    "skip-build": {
+      type: "boolean",
+      description: "Watch output dirs directly, skip build command detection",
+      default: false
+    },
+    debounce: {
+      type: "string",
+      description: "Debounce delay in ms for watch mode (default: 300)"
+    }
+  },
+  async run({ args }) {
+    suppressHumanOutput();
+    const packageDir = resolve(".");
+    const doPush = async () => {
+      const timer = new Timer();
+      const result = await publish(packageDir);
+      if (result.skipped) {
+        consola.info("No changes to push");
+        return;
+      }
+      const entry = await getStoreEntry(result.name, result.version);
+      if (!entry) {
+        errorWithSuggestion("Failed to read store entry after publish");
+        return;
+      }
+      const consumers = await getConsumers(result.name);
+      if (consumers.length === 0) {
+        consola.info(
+          "No consumers registered. Use 'plunk add' in a consumer project first."
+        );
+        return;
+      }
+      let totalCopied = 0;
+      let totalSkipped = 0;
+      let pushCount = 0;
+      const results = await Promise.all(
+        consumers.map(
+          (consumerPath) => consumerLimit(async () => {
+            const link = await getLink(consumerPath, result.name);
+            if (!link) {
+              verbose(`[push] No link found for ${result.name} in ${consumerPath}, skipping`);
+              return null;
+            }
+            try {
+              const injectResult = await inject(
+                entry,
+                consumerPath,
+                link.packageManager
+              );
+              if (injectResult.copied > 0 || injectResult.removed > 0) {
+                await addLink(consumerPath, result.name, {
+                  ...link,
+                  contentHash: entry.meta.contentHash,
+                  linkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  buildId: entry.meta.buildId ?? ""
+                });
+              }
+              return injectResult;
+            } catch (err) {
+              consola.warn(`Failed to push to ${consumerPath}: ${err}`);
+              return null;
+            }
+          })
+        )
+      );
+      for (const r of results) {
+        if (r) {
+          totalCopied += r.copied;
+          totalSkipped += r.skipped;
+          pushCount++;
+        }
+      }
+      const buildTag = result.buildId ? ` [${result.buildId}]` : "";
+      consola.success(
+        `Pushed ${result.name}@${result.version}${buildTag} to ${pushCount} consumer(s) in ${timer.elapsed()} (${totalCopied} files changed, ${totalSkipped} unchanged)`
+      );
+      output({
+        name: result.name,
+        version: result.version,
+        buildId: result.buildId,
+        consumers: pushCount,
+        copied: totalCopied,
+        skipped: totalSkipped,
+        elapsed: timer.elapsedMs()
+      });
+    };
+    await doPush();
+    if (args.watch) {
+      let buildCmd = args.build;
+      let patterns;
+      if (args.build) {
+      } else if (args["skip-build"]) {
+      } else {
+        const pm = await detectPackageManager(packageDir);
+        const detected = await detectBuildCommand(packageDir, pm);
+        if (detected) {
+          buildCmd = detected;
+          consola.info(`Auto-detected build command: ${detected}`);
+        }
+      }
+      if (!buildCmd) {
+        try {
+          const pkg = JSON.parse(
+            await readFile(join(packageDir, "package.json"), "utf-8")
+          );
+          if (pkg.files && pkg.files.length > 0) {
+            patterns = pkg.files;
+            verbose(`[watch] Using package.json files field: ${patterns.join(", ")}`);
+          }
+        } catch {
+        }
+      }
+      await startWatcher(
+        packageDir,
+        {
+          patterns,
+          buildCmd,
+          debounce: args.debounce ? parseInt(args.debounce, 10) : void 0
+        },
+        doPush
+      );
+      await new Promise(() => {
+      });
+    }
+  }
+});
+export {
+  push_default as default
+};

package/dist/remove-DCR7KKD5.mjs

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  removeFromTranspilePackages
+} from "./chunk-WSECI6M7.mjs";
+import {
+  removeInjected,
+  restoreBackup
+} from "./chunk-CZM4TNAI.mjs";
+import {
+  detectBundler
+} from "./chunk-34UXZ622.mjs";
+import {
+  getLink,
+  readConsumerState,
+  removeLink,
+  unregisterConsumer
+} from "./chunk-GAAB2TLH.mjs";
+import {
+  errorWithSuggestion
+} from "./chunk-S4HJSJ32.mjs";
+import {
+  Timer
+} from "./chunk-XZK5T4GK.mjs";
+import "./chunk-PUSXMPOF.mjs";
+import "./chunk-EDUXIQ5W.mjs";
+import {
+  output,
+  suppressHumanOutput
+} from "./chunk-ZOYNYK5Y.mjs";
+import {
+  defineCommand
+} from "./chunk-CSMZ6DZA.mjs";
+import "./chunk-HKNM3UWU.mjs";
+import {
+  consola,
+  verbose
+} from "./chunk-I6SN7BBN.mjs";
+import "./chunk-KYDBD2KQ.mjs";
+
+// src/commands/remove.ts
+import { resolve, basename } from "path";
+var remove_default = defineCommand({
+  meta: {
+    name: "remove",
+    description: "Remove a plunk-linked package and restore the original"
+  },
+  args: {
+    package: {
+      type: "positional",
+      description: "Package name to remove",
+      required: false
+    },
+    all: {
+      type: "boolean",
+      description: "Remove all linked packages",
+      default: false
+    },
+    force: {
+      type: "boolean",
+      description: "Skip error checking",
+      default: false
+    }
+  },
+  async run({ args }) {
+    suppressHumanOutput();
+    const timer = new Timer();
+    const consumerPath = resolve(".");
+    if (args.all) {
+      const state = await readConsumerState(consumerPath);
+      const links = Object.entries(state.links);
+      if (links.length === 0) {
+        consola.info("No linked packages to remove");
+        output({ removed: 0 });
+        return;
+      }
+      let removed = 0;
+      for (const [packageName2, link2] of links) {
+        await removeSinglePackage(consumerPath, packageName2, link2);
+        removed++;
+      }
+      consola.success(`Removed ${removed} plunk link(s) in ${timer.elapsed()}`);
+      output({ removed, elapsed: timer.elapsedMs() });
+      return;
+    }
+    const packageName = args.package;
+    if (!packageName) {
+      errorWithSuggestion("Package name required. Use --all to remove all linked packages.");
+      process.exit(1);
+    }
+    const link = await getLink(consumerPath, packageName);
+    if (!link) {
+      if (args.force) {
+        consola.warn(`Package "${packageName}" is not linked, skipping`);
+        output({ removed: 0 });
+        return;
+      }
+      errorWithSuggestion(`Package "${packageName}" is not linked in this project`);
+      process.exit(1);
+    }
+    await removeSinglePackage(consumerPath, packageName, link);
+    consola.success(`Removed plunk link for ${packageName} in ${timer.elapsed()}`);
+    output({ removed: 1, package: packageName, elapsed: timer.elapsedMs() });
+  }
+});
+async function removeSinglePackage(consumerPath, packageName, link) {
+  verbose(`[remove] Removing ${packageName}`);
+  await removeInjected(consumerPath, packageName, link.packageManager);
+  if (link.backupExists) {
+    const restored = await restoreBackup(
+      consumerPath,
+      packageName,
+      link.packageManager
+    );
+    if (restored) {
+      consola.success(`Restored original ${packageName} from backup`);
+    }
+  }
+  const bundler = await detectBundler(consumerPath);
+  if (bundler.type === "next" && bundler.configFile) {
+    const result = await removeFromTranspilePackages(bundler.configFile, packageName);
+    if (result.modified) {
+      verbose(`[remove] Removed ${packageName} from ${basename(bundler.configFile)}`);
+    }
+  }
+  const { findTailwindCss, removeTailwindSource } = await import("./tailwind-source-JBBEIXIJ.mjs");
+  const tailwindCss = await findTailwindCss(consumerPath);
+  if (tailwindCss) {
+    const twResult = await removeTailwindSource(tailwindCss, packageName);
+    if (twResult.modified) {
+      verbose(`[remove] Removed @source for ${packageName} from ${basename(tailwindCss)}`);
+    }
+  }
+  await removeLink(consumerPath, packageName);
+  await unregisterConsumer(packageName, consumerPath);
+  if (bundler.type === "vite" && bundler.configFile) {
+    const state = await readConsumerState(consumerPath);
+    if (Object.keys(state.links).length === 0) {
+      const { removeFromViteConfig } = await import("./vite-config-BAK67JHB.mjs");
+      const result = await removeFromViteConfig(bundler.configFile);
+      if (result.modified) {
+        verbose(`[remove] Removed plunk plugin from ${basename(bundler.configFile)}`);
+      }
+    }
+  }
+}
+export {
+  remove_default as default
+};

package/dist/restore-SUN3WGSW.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  inject
+} from "./chunk-CZM4TNAI.mjs";
+import {
+  detectPackageManager,
+  detectYarnNodeLinker,
+  hasYarnrcYml
+} from "./chunk-34UXZ622.mjs";
+import {
+  readConsumerState
+} from "./chunk-GAAB2TLH.mjs";
+import {
+  getStoreEntry
+} from "./chunk-W3C72UKC.mjs";
+import {
+  Timer
+} from "./chunk-XZK5T4GK.mjs";
+import "./chunk-EDUXIQ5W.mjs";
+import {
+  output,
+  suppressHumanOutput
+} from "./chunk-ZOYNYK5Y.mjs";
+import {
+  defineCommand
+} from "./chunk-CSMZ6DZA.mjs";
+import {
+  pLimit
+} from "./chunk-HKNM3UWU.mjs";
+import {
+  consola,
+  verbose
+} from "./chunk-I6SN7BBN.mjs";
+import "./chunk-KYDBD2KQ.mjs";
+
+// src/commands/restore.ts
+import { resolve } from "path";
+var restoreLimit = pLimit(4);
+var restore_default = defineCommand({
+  meta: {
+    name: "restore",
+    description: "Re-inject all linked packages (use after npm install wipes overrides)"
+  },
+  args: {
+    silent: {
+      type: "boolean",
+      description: "Suppress output when no packages are linked (for postinstall scripts)",
+      default: false
+    }
+  },
+  async run({ args }) {
+    suppressHumanOutput();
+    const timer = new Timer();
+    const consumerPath = resolve(".");
+    const state = await readConsumerState(consumerPath);
+    const pm = await detectPackageManager(consumerPath);
+    if (pm === "yarn") {
+      const linker = await detectYarnNodeLinker(consumerPath);
+      if (linker === "pnp" || linker === null && await hasYarnrcYml(consumerPath)) {
+        consola.error(
+          `Yarn PnP mode is not compatible with plunk.
+
+plunk works by copying files into node_modules/, but PnP eliminates
+node_modules/ entirely. To use plunk with Yarn Berry, add this to
+.yarnrc.yml:
+
+  nodeLinker: node-modules
+
+Then run: yarn install`
+        );
+        process.exit(1);
+      }
+    }
+    const links = Object.entries(state.links);
+    if (links.length === 0) {
+      if (!args.silent) {
+        consola.info("No linked packages in this project");
+      }
+      output({ restored: 0, failed: 0 });
+      return;
+    }
+    let restored = 0;
+    let failed = 0;
+    const results = await Promise.all(
+      links.map(
+        ([packageName, link]) => restoreLimit(async () => {
+          const entry = await getStoreEntry(packageName, link.version);
+          if (!entry) {
+            consola.warn(
+              `Store entry missing for ${packageName}@${link.version}. Re-publish it.`
+            );
+            return { packageName, success: false };
+          }
+          try {
+            const result = await inject(entry, consumerPath, link.packageManager);
+            verbose(`[restore] ${packageName}@${link.version}: ${result.copied} files`);
+            return { packageName, success: true, copied: result.copied };
+          } catch (err) {
+            consola.error(`Failed to restore ${packageName}: ${err}`);
+            return { packageName, success: false };
+          }
+        })
+      )
+    );
+    for (const r of results) {
+      if (r.success) {
+        consola.success(
+          `Restored ${r.packageName} (${r.copied} files)`
+        );
+        restored++;
+      } else {
+        failed++;
+      }
+    }
+    consola.info(
+      `Restore complete: ${restored} restored, ${failed} failed in ${timer.elapsed()}`
+    );
+    output({ restored, failed, elapsed: timer.elapsedMs() });
+  }
+});
+export {
+  restore_default as default
+};

package/dist/status-MESRBH54.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  readConsumerState
+} from "./chunk-GAAB2TLH.mjs";
+import {
+  getStoreEntry
+} from "./chunk-W3C72UKC.mjs";
+import {
+  require_picocolors
+} from "./chunk-PUSXMPOF.mjs";
+import "./chunk-EDUXIQ5W.mjs";
+import {
+  output,
+  suppressHumanOutput
+} from "./chunk-ZOYNYK5Y.mjs";
+import {
+  defineCommand
+} from "./chunk-CSMZ6DZA.mjs";
+import {
+  exists,
+  pLimit
+} from "./chunk-HKNM3UWU.mjs";
+import {
+  consola
+} from "./chunk-I6SN7BBN.mjs";
+import {
+  __toESM
+} from "./chunk-KYDBD2KQ.mjs";
+
+// src/commands/status.ts
+import { resolve, join } from "path";
+var import_picocolors = __toESM(require_picocolors(), 1);
+var checkLimit = pLimit(4);
+var status_default = defineCommand({
+  meta: {
+    name: "status",
+    description: "Show status of linked packages with health checks"
+  },
+  async run() {
+    suppressHumanOutput();
+    const consumerPath = resolve(".");
+    const state = await readConsumerState(consumerPath);
+    const links = Object.entries(state.links);
+    if (links.length === 0) {
+      consola.info("No linked packages in this project");
+      output({ packages: [] });
+      return;
+    }
+    consola.info(`Package status (${links.length} linked):
+`);
+    const statuses = await Promise.all(
+      links.map(
+        ([name, link]) => checkLimit(async () => {
+          const issues = [];
+          const entry = await getStoreEntry(name, link.version);
+          if (!entry) {
+            issues.push("store entry missing");
+          } else if (entry.meta.contentHash !== link.contentHash) {
+            issues.push("unpublished changes in store");
+          }
+          const nmPath = join(consumerPath, "node_modules", name);
+          if (!await exists(nmPath)) {
+            issues.push("missing from node_modules (run plunk restore)");
+          }
+          return {
+            name,
+            version: link.version,
+            buildId: link.buildId ?? "",
+            issues,
+            linkedAt: link.linkedAt,
+            sourcePath: link.sourcePath
+          };
+        })
+      )
+    );
+    for (const s of statuses) {
+      const statusIcon = s.issues.length === 0 ? import_picocolors.default.green("\u2713") : import_picocolors.default.yellow("!");
+      const buildTag = s.buildId ? `[${s.buildId}]` : "[--------]";
+      console.log(
+        `  ${statusIcon} ${import_picocolors.default.cyan(s.name)} ${import_picocolors.default.dim("@" + s.version)} ${import_picocolors.default.dim(buildTag)}`
+      );
+      console.log(
+        `    ${import_picocolors.default.dim(`linked ${new Date(s.linkedAt).toLocaleString()} from ${s.sourcePath}`)}`
+      );
+      for (const issue of s.issues) {
+        console.log(`    ${import_picocolors.default.yellow("\u26A0")} ${issue}`);
+      }
+    }
+    output({
+      packages: statuses.map(({ name, version, buildId, issues }) => ({
+        name,
+        version,
+        buildId: buildId || null,
+        healthy: issues.length === 0,
+        issues
+      }))
+    });
+  }
+});
+export {
+  status_default as default
+};