exportc 0.0.1

package/README.md

@@ -0,0 +1,103 @@
+# exportc
+
+Add [export](https://github.com/ihasq/export) to existing Vite projects.
+
+## Quick Start
+
+```bash
+# In your existing Vite project
+npx exportc init
+
+# Install dependencies
+cd export && npm install
+
+# Start development (two terminals)
+npm run export:dev   # Terminal 1: Wrangler dev server
+npm run dev          # Terminal 2: Vite dev server
+```
+
+## Usage
+
+After initialization, import your server exports using the `export:/` prefix:
+
+```typescript
+// In your Vite app
+import { hello, Counter } from "export:/";
+
+const message = await hello("World");  // "Hello, World!"
+
+const counter = await new Counter(0);
+await counter.increment();  // 1
+```
+
+## Commands
+
+### `exportc init`
+
+Initialize export in your Vite project:
+- Creates `export/` directory with example server code
+- Updates `vite.config.ts` with the export plugin
+- Adds npm scripts for development and deployment
+
+### `exportc dev`
+
+Start the Wrangler development server for your exports.
+
+### `exportc deploy`
+
+Deploy your exports to Cloudflare Workers.
+
+## Vite Plugin
+
+The `exportPlugin` transforms `export:/` imports:
+
+```typescript
+// vite.config.ts
+import { defineConfig } from "vite";
+import { exportPlugin } from "exportc/vite";
+
+export default defineConfig({
+  plugins: [
+    exportPlugin({
+      // Development server (default: http://localhost:8787)
+      dev: "http://localhost:8787",
+      // Production Worker URL (required for production builds)
+      production: "https://my-api.workers.dev",
+    }),
+  ],
+});
+```
+
+## Project Structure
+
+After running `exportc init`:
+
+```
+my-vite-app/
+├── src/                    # Your Vite app
+├── export/                 # Server exports (Cloudflare Worker)
+│   ├── index.ts           # Your server code
+│   └── package.json       # Worker configuration
+├── export-env.d.ts        # TypeScript declarations
+└── vite.config.ts         # Updated with exportPlugin
+```
+
+## TypeScript Support
+
+The `export-env.d.ts` file provides type declarations for `export:/` imports. Update it when you add new exports:
+
+```typescript
+// export-env.d.ts
+declare module "export:/" {
+  export function hello(name: string): Promise<string>;
+  export function myNewFunction(): Promise<void>;
+}
+
+declare module "export:/utils" {
+  export function formatDate(date: Date): Promise<string>;
+}
+```
+
+## License
+
+MIT

package/commands/deploy.js

@@ -0,0 +1,64 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+export async function deploy(argv) {
+  const cwd = process.cwd();
+  const exportDir = path.join(cwd, "export");
+
+  // Check if export directory exists
+  if (!fs.existsSync(exportDir)) {
+    p.cancel(`No export/ directory found. Run ${pc.cyan("exportc init")} first.`);
+    process.exit(1);
+  }
+
+  // Check if dependencies are installed
+  const nodeModules = path.join(exportDir, "node_modules");
+  if (!fs.existsSync(nodeModules)) {
+    p.cancel(`Dependencies not installed. Run ${pc.cyan("cd export && npm install")} first.`);
+    process.exit(1);
+  }
+
+  p.intro(pc.bgCyan(pc.black(" exportc deploy ")));
+
+  const s = p.spinner();
+  s.start("Deploying to Cloudflare Workers...");
+
+  // Run deploy
+  const deployProcess = spawn("npm", ["run", "deploy"], {
+    cwd: exportDir,
+    stdio: "inherit",
+    shell: true,
+  });
+
+  const exitCode = await new Promise((resolve) => {
+    deployProcess.on("close", resolve);
+    deployProcess.on("error", () => resolve(1));
+  });
+
+  if (exitCode !== 0) {
+    s.stop("Deployment failed");
+    process.exit(1);
+  }
+
+  s.stop("Deployed successfully!");
+
+  // Read worker name from export/package.json
+  const exportPkgPath = path.join(exportDir, "package.json");
+  const exportPkg = JSON.parse(fs.readFileSync(exportPkgPath, "utf8"));
+  const workerName = exportPkg.name;
+
+  p.note(
+    `Your exports are now live at:
+${pc.cyan(`https://${workerName}.workers.dev/`)}
+
+${pc.bold("Update your Vite config for production:")}
+${pc.dim("// vite.config.ts")}
+${pc.cyan(`exportPlugin({ production: "https://${workerName}.workers.dev" })`)}`,
+    "Deployed"
+  );
+
+  p.outro("Done!");
+}

package/commands/dev.js

@@ -0,0 +1,57 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+export async function dev(argv) {
+  const cwd = process.cwd();
+  const exportDir = path.join(cwd, "export");
+
+  // Check if export directory exists
+  if (!fs.existsSync(exportDir)) {
+    p.cancel(`No export/ directory found. Run ${pc.cyan("exportc init")} first.`);
+    process.exit(1);
+  }
+
+  // Check if dependencies are installed
+  const nodeModules = path.join(exportDir, "node_modules");
+  if (!fs.existsSync(nodeModules)) {
+    p.cancel(`Dependencies not installed. Run ${pc.cyan("cd export && npm install")} first.`);
+    process.exit(1);
+  }
+
+  p.intro(pc.bgCyan(pc.black(" exportc dev ")));
+
+  const s = p.spinner();
+  s.start("Starting export dev server...");
+
+  // Generate types first
+  const generateTypes = spawn("npm", ["run", "dev"], {
+    cwd: exportDir,
+    stdio: "inherit",
+    shell: true,
+  });
+
+  generateTypes.on("error", (err) => {
+    s.stop("Failed to start dev server");
+    console.error(pc.red(err.message));
+    process.exit(1);
+  });
+
+  s.stop("Export dev server started!");
+
+  p.note(
+    `Wrangler dev server is running at ${pc.cyan("http://localhost:8787")}
+
+${pc.bold("In your Vite app:")}
+${pc.cyan(`import { hello } from "export:/";`)}
+${pc.cyan(`const message = await hello("World");`)}
+
+${pc.dim("Press Ctrl+C to stop")}`,
+    "Running"
+  );
+
+  // Keep the process running
+  await new Promise(() => {});
+}

package/commands/init.js

@@ -0,0 +1,310 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function init(argv) {
+  const cwd = process.cwd();
+
+  p.intro(pc.bgCyan(pc.black(" exportc init ")));
+
+  // Check for Vite project
+  const viteConfigFiles = ["vite.config.ts", "vite.config.js", "vite.config.mts", "vite.config.mjs"];
+  const viteConfig = viteConfigFiles.find((f) => fs.existsSync(path.join(cwd, f)));
+
+  if (!viteConfig) {
+    p.cancel("No Vite config found. exportc currently only supports Vite projects.");
+    process.exit(1);
+  }
+
+  // Check for package.json
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    p.cancel("No package.json found.");
+    process.exit(1);
+  }
+
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+
+  // Check if already initialized
+  const exportDir = path.join(cwd, "export");
+  if (fs.existsSync(exportDir)) {
+    const overwrite = await p.confirm({
+      message: "export/ directory already exists. Continue and overwrite?",
+      initialValue: false,
+    });
+    if (p.isCancel(overwrite) || !overwrite) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+  }
+
+  // Get worker name
+  const workerName = await p.text({
+    message: "Worker name:",
+    placeholder: pkg.name ? `${pkg.name}-api` : "my-api",
+    defaultValue: pkg.name ? `${pkg.name}-api` : "my-api",
+    validate: (v) => {
+      if (!v) return "Worker name is required";
+      if (!/^[a-z0-9-]+$/.test(v)) return "Use lowercase letters, numbers, and hyphens only";
+    },
+  });
+
+  if (p.isCancel(workerName)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+
+  // Check for TypeScript
+  const isTypeScript = viteConfig.endsWith(".ts") || viteConfig.endsWith(".mts") ||
+    fs.existsSync(path.join(cwd, "tsconfig.json"));
+
+  const s = p.spinner();
+  s.start("Initializing export...");
+
+  // Create export directory
+  if (!fs.existsSync(exportDir)) {
+    fs.mkdirSync(exportDir, { recursive: true });
+  }
+
+  // Create export/index.ts or index.js
+  const ext = isTypeScript ? "ts" : "js";
+  const indexPath = path.join(exportDir, `index.${ext}`);
+  if (!fs.existsSync(indexPath)) {
+    const template = isTypeScript
+      ? `// Server-side exports - these will be available to your client code
+// Import from "export:/" in your client code
+
+export async function hello(name: string): Promise<string> {
+  return \`Hello, \${name}!\`;
+}
+
+export function add(a: number, b: number): number {
+  return a + b;
+}
+
+export class Counter {
+  private count: number;
+
+  constructor(initial: number = 0) {
+    this.count = initial;
+  }
+
+  increment(): number {
+    return ++this.count;
+  }
+
+  getCount(): number {
+    return this.count;
+  }
+}
+`
+      : `// Server-side exports - these will be available to your client code
+// Import from "export:/" in your client code
+
+export async function hello(name) {
+  return \`Hello, \${name}!\`;
+}
+
+export function add(a, b) {
+  return a + b;
+}
+
+export class Counter {
+  #count;
+
+  constructor(initial = 0) {
+    this.#count = initial;
+  }
+
+  increment() {
+    return ++this.#count;
+  }
+
+  getCount() {
+    return this.#count;
+  }
+}
+`;
+    fs.writeFileSync(indexPath, template);
+  }
+
+  // Create export/package.json
+  const exportPkgPath = path.join(exportDir, "package.json");
+  const exportPkg = {
+    name: workerName,
+    private: true,
+    type: "module",
+    exports: "./",
+    scripts: {
+      dev: "generate-export-types && wrangler dev",
+      deploy: "generate-export-types && wrangler deploy",
+    },
+    dependencies: {
+      "export-runtime": "^0.0.14",
+    },
+    devDependencies: {
+      wrangler: "^4.0.0",
+    },
+  };
+
+  if (isTypeScript) {
+    exportPkg.devDependencies["@cloudflare/workers-types"] = "^4.20241127.0";
+  }
+
+  fs.writeFileSync(exportPkgPath, JSON.stringify(exportPkg, null, 2) + "\n");
+
+  // Update main package.json scripts
+  pkg.scripts = pkg.scripts || {};
+  if (!pkg.scripts["export:dev"]) {
+    pkg.scripts["export:dev"] = "cd export && npm run dev";
+  }
+  if (!pkg.scripts["export:deploy"]) {
+    pkg.scripts["export:deploy"] = "cd export && npm run deploy";
+  }
+
+  // Add exportc to devDependencies
+  pkg.devDependencies = pkg.devDependencies || {};
+  if (!pkg.devDependencies.exportc) {
+    pkg.devDependencies.exportc = "^0.0.1";
+  }
+
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+
+  // Update vite.config
+  const viteConfigPath = path.join(cwd, viteConfig);
+  let viteConfigContent = fs.readFileSync(viteConfigPath, "utf8");
+
+  // Check if export plugin is already added
+  if (!viteConfigContent.includes("exportc/vite")) {
+    // Add import at the top
+    const importStatement = `import { exportPlugin } from "exportc/vite";\n`;
+
+    // Find the first import or the start of the file
+    const importMatch = viteConfigContent.match(/^(import\s+.+\s+from\s+['"].+['"];?\s*\n?)+/m);
+    if (importMatch) {
+      const insertPos = importMatch.index + importMatch[0].length;
+      viteConfigContent =
+        viteConfigContent.slice(0, insertPos) +
+        importStatement +
+        viteConfigContent.slice(insertPos);
+    } else {
+      viteConfigContent = importStatement + viteConfigContent;
+    }
+
+    // Add plugin to defineConfig
+    // Look for plugins array
+    if (viteConfigContent.includes("plugins:")) {
+      // Add to existing plugins array
+      viteConfigContent = viteConfigContent.replace(
+        /plugins:\s*\[/,
+        "plugins: [exportPlugin(), "
+      );
+    } else {
+      // Add plugins array to defineConfig
+      viteConfigContent = viteConfigContent.replace(
+        /defineConfig\(\s*\{/,
+        "defineConfig({\n  plugins: [exportPlugin()],"
+      );
+    }
+
+    fs.writeFileSync(viteConfigPath, viteConfigContent);
+  }
+
+  // Create .gitignore entries for export directory
+  const exportGitignorePath = path.join(exportDir, ".gitignore");
+  const gitignoreContent = `# Generated files
+.export-*.js
+.export-*.d.ts
+export.d.ts
+wrangler.toml
+.wrangler/
+.dev.vars
+`;
+  fs.writeFileSync(exportGitignorePath, gitignoreContent);
+
+  // Create export-env.d.ts in main project for TypeScript support
+  if (isTypeScript) {
+    const envDtsPath = path.join(cwd, "export-env.d.ts");
+    if (!fs.existsSync(envDtsPath)) {
+      const envDtsContent = `// Type declarations for export:/ imports
+// This file is auto-generated by exportc. You can modify it to add custom types.
+
+// Re-export types from your export directory
+// Update this when you add new exports
+
+declare module "export:/" {
+  export function hello(name: string): Promise<string>;
+  export function add(a: number, b: number): Promise<number>;
+  export class Counter {
+    constructor(initial?: number);
+    increment(): Promise<number>;
+    getCount(): Promise<number>;
+    [Symbol.dispose](): Promise<void>;
+  }
+}
+
+// Add more module declarations for subpaths:
+// declare module "export:/utils" {
+//   export function myUtil(): Promise<void>;
+// }
+`;
+      fs.writeFileSync(envDtsPath, envDtsContent);
+    }
+
+    // Update tsconfig.json to include the type declarations
+    const tsconfigPath = path.join(cwd, "tsconfig.json");
+    if (fs.existsSync(tsconfigPath)) {
+      try {
+        const tsconfigContent = fs.readFileSync(tsconfigPath, "utf8");
+        const tsconfig = JSON.parse(tsconfigContent);
+
+        // Add export-env.d.ts to include if not already present
+        tsconfig.include = tsconfig.include || [];
+        if (!tsconfig.include.includes("export-env.d.ts")) {
+          tsconfig.include.push("export-env.d.ts");
+          fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+        }
+      } catch {
+        // Ignore JSON parse errors (might have comments)
+      }
+    }
+  }
+
+  s.stop("Export initialized!");
+
+  const filesCreated = isTypeScript
+    ? `${pc.cyan("export/")}
+├── index.${ext}        ${pc.dim("# Your server exports")}
+├── package.json    ${pc.dim("# Worker configuration")}
+└── .gitignore
+
+${pc.cyan("export-env.d.ts")}     ${pc.dim("# Type declarations for export:/ imports")}`
+    : `${pc.cyan("export/")}
+├── index.${ext}        ${pc.dim("# Your server exports")}
+├── package.json    ${pc.dim("# Worker configuration")}
+└── .gitignore`;
+
+  p.note(
+    `${filesCreated}
+
+${pc.bold("Next steps:")}
+
+1. Install dependencies:
+   ${pc.cyan("cd export && npm install")}
+
+2. Start development:
+   ${pc.cyan("npm run export:dev")}   ${pc.dim("# In one terminal")}
+   ${pc.cyan("npm run dev")}          ${pc.dim("# In another terminal")}
+
+3. Import in your client code:
+   ${pc.cyan(`import { hello } from "export:/";`)}
+   ${pc.cyan(`const message = await hello("World");`)}`,
+    "Created"
+  );
+
+  p.outro(`Run ${pc.cyan("cd export && npm install")} to get started!`);
+}

package/index.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+import mri from "mri";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { init } from "./commands/init.js";
+import { dev } from "./commands/dev.js";
+import { deploy } from "./commands/deploy.js";
+
+const argv = mri(process.argv.slice(2), {
+  alias: {
+    h: "help",
+    v: "version",
+  },
+  boolean: ["help", "version"],
+});
+
+const command = argv._[0];
+
+const HELP = `
+${pc.bold("exportc")} - Add export to existing projects
+
+${pc.bold("Usage:")}
+  exportc <command> [options]
+
+${pc.bold("Commands:")}
+  init          Initialize export in an existing Vite project
+  dev           Start development server (Vite + Wrangler)
+  deploy        Deploy to Cloudflare Workers
+
+${pc.bold("Options:")}
+  -h, --help    Show this help message
+  -v, --version Show version number
+
+${pc.bold("Examples:")}
+  ${pc.dim("# Add export to your Vite project")}
+  npx exportc init
+
+  ${pc.dim("# Start development")}
+  npx exportc dev
+
+  ${pc.dim("# Deploy to Cloudflare")}
+  npx exportc deploy
+`;
+
+if (argv.help || !command) {
+  console.log(HELP);
+  process.exit(0);
+}
+
+if (argv.version) {
+  const pkg = await import("./package.json", { with: { type: "json" } });
+  console.log(pkg.default.version);
+  process.exit(0);
+}
+
+const commands = {
+  init,
+  dev,
+  deploy,
+};
+
+const handler = commands[command];
+if (!handler) {
+  console.error(pc.red(`Unknown command: ${command}`));
+  console.log(HELP);
+  process.exit(1);
+}
+
+try {
+  await handler(argv);
+} catch (err) {
+  p.cancel(err.message);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "exportc",
+  "version": "0.0.1",
+  "description": "CLI to add export to existing projects",
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "keywords": [
+    "cloudflare",
+    "workers",
+    "vite",
+    "esm",
+    "rpc"
+  ],
+  "homepage": "https://github.com/ihasq/export#readme",
+  "bugs": {
+    "url": "https://github.com/ihasq/export/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ihasq/export.git",
+    "directory": "packages/exportc"
+  },
+  "license": "MIT",
+  "author": "ihasq",
+  "type": "module",
+  "bin": {
+    "exportc": "./index.js"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./vite": "./vite-plugin.js"
+  },
+  "files": [
+    "index.js",
+    "vite-plugin.js",
+    "vite-plugin.d.ts",
+    "commands"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.8.2",
+    "mri": "^1.2.0",
+    "picocolors": "^1.1.1"
+  },
+  "peerDependencies": {
+    "vite": "^5.0.0 || ^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  }
+}

package/vite-plugin.d.ts

@@ -0,0 +1,41 @@
+import type { Plugin } from "vite";
+
+export interface ExportPluginOptions {
+  /**
+   * Development server URL
+   * @default "http://localhost:8787"
+   */
+  dev?: string;
+
+  /**
+   * Production Worker URL
+   * Required for production builds
+   * @example "https://my-api.workers.dev"
+   */
+  production?: string;
+}
+
+/**
+ * Vite plugin for export integration
+ *
+ * Allows importing server exports using the "export:/" prefix:
+ * ```ts
+ * import { hello } from "export:/";
+ * import { utils } from "export:/utils";
+ * ```
+ *
+ * @example
+ * // vite.config.ts
+ * import { exportPlugin } from "exportc/vite";
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     exportPlugin({
+ *       production: "https://my-api.workers.dev"
+ *     })
+ *   ]
+ * });
+ */
+export function exportPlugin(options?: ExportPluginOptions): Plugin;
+
+export default exportPlugin;

package/vite-plugin.js

@@ -0,0 +1,144 @@
+/**
+ * Vite plugin for export integration
+ *
+ * Allows importing server exports using the "export:/" prefix:
+ *   import { hello } from "export:/";
+ *   import { utils } from "export:/utils";
+ *
+ * In development, proxies to local Wrangler dev server (localhost:8787)
+ * In production, resolves to the deployed Worker URL
+ */
+
+const EXPORT_PREFIX = "export:";
+const DEFAULT_DEV_URL = "http://localhost:8787";
+
+/**
+ * @param {Object} options
+ * @param {string} [options.dev] - Development server URL (default: http://localhost:8787)
+ * @param {string} [options.production] - Production Worker URL (required for production builds)
+ * @returns {import('vite').Plugin}
+ */
+export function exportPlugin(options = {}) {
+  const devUrl = options.dev || DEFAULT_DEV_URL;
+  const prodUrl = options.production;
+
+  let isDev = true;
+
+  return {
+    name: "vite-plugin-export",
+
+    config(config, { command }) {
+      isDev = command === "serve";
+
+      // Add proxy for development
+      if (isDev) {
+        return {
+          server: {
+            proxy: {
+              // Proxy WebSocket connections
+              "^/__export_ws__": {
+                target: devUrl.replace(/^http/, "ws"),
+                ws: true,
+                rewrite: (path) => path.replace("/__export_ws__", ""),
+              },
+            },
+          },
+        };
+      }
+    },
+
+    resolveId(source) {
+      if (source.startsWith(EXPORT_PREFIX)) {
+        // Mark as external - we'll handle it in load
+        return { id: source, external: false };
+      }
+      return null;
+    },
+
+    load(id) {
+      if (!id.startsWith(EXPORT_PREFIX)) {
+        return null;
+      }
+
+      // Extract the path after "export:"
+      const exportPath = id.slice(EXPORT_PREFIX.length) || "/";
+
+      // In development, use the local dev server
+      // In production, use the configured production URL
+      const baseUrl = isDev ? devUrl : prodUrl;
+
+      if (!baseUrl) {
+        if (!isDev) {
+          this.error(
+            `[exportc] Production URL not configured. Add { production: "https://your-worker.workers.dev" } to exportPlugin() in vite.config.`
+          );
+        }
+        this.error(`[exportc] Could not resolve base URL for export imports.`);
+      }
+
+      // Build the full URL
+      const fullUrl = new URL(exportPath, baseUrl).href;
+
+      // Generate a module that re-exports from the Worker URL
+      // For development, we dynamically import from the Worker
+      // For production, we use the deployed URL
+      const code = `
+// Auto-generated by exportc/vite
+// Importing from: ${fullUrl}
+export * from "${fullUrl}";
+export { default } from "${fullUrl}";
+`;
+
+      return code;
+    },
+
+    // Transform import statements in the final bundle for production
+    transform(code, id) {
+      // Skip node_modules and non-JS files
+      if (id.includes("node_modules") || !/\.(js|ts|jsx|tsx|vue|svelte)$/.test(id)) {
+        return null;
+      }
+
+      // Replace dynamic imports of export: URLs
+      if (code.includes('import("export:') || code.includes("import('export:")) {
+        const baseUrl = isDev ? devUrl : prodUrl;
+        if (!baseUrl && !isDev) {
+          this.warn(
+            `[exportc] Production URL not configured for dynamic imports in ${id}`
+          );
+          return null;
+        }
+
+        // Replace export:/ with the actual URL
+        const transformed = code.replace(
+          /import\((['"])export:([^'"]*)\1\)/g,
+          (match, quote, path) => {
+            const fullUrl = new URL(path || "/", baseUrl).href;
+            return `import(${quote}${fullUrl}${quote})`;
+          }
+        );
+
+        if (transformed !== code) {
+          return { code: transformed, map: null };
+        }
+      }
+
+      return null;
+    },
+
+    // Generate TypeScript declarations hint
+    buildStart() {
+      if (isDev) {
+        this.info(
+          `[exportc] Development mode - proxying to ${devUrl}`
+        );
+      } else if (prodUrl) {
+        this.info(
+          `[exportc] Production mode - using ${prodUrl}`
+        );
+      }
+    },
+  };
+}
+
+export default exportPlugin;