jiek 2.2.6 → 2.2.7-alpha.1

package/bin/build.cjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('jiek/bin-helper')

package/bin/index.cjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('jiek/bin-helper')

package/bin-helper/index.cjs

@@ -0,0 +1,31 @@
+const fs = require('node:fs')
+const {
+  basename,
+  dirname,
+  resolve
+} = require('node:path')
+const process = require('node:process')
+
+/**
+ * @type {string | undefined}
+ */
+const binFilePath = process.env.JIEK_BIN__FILEPATH ?? module.parent.filename ?? require.main.filename
+
+const packageDir = dirname(dirname(binFilePath))
+const binFilename = basename(binFilePath)
+
+process.env.JIEK_PACKAGE_DIR = packageDir
+process.env.JIEK_BIN__FILENAME = binFilename
+process.env.JIEK_BIN__FILEPATH = binFilePath
+
+const resolveByPKG = (...paths) => resolve(packageDir, ...paths)
+const isProduction = fs.existsSync(resolveByPKG(`./.jiek-production-tag`))
+
+if (!isProduction) {
+  require('esbuild-register')
+}
+
+const binPath = isProduction
+  ? resolveByPKG(`./dist/bin/${binFilename}`)
+  : resolveByPKG(`./src/bin/${binFilename.replace(/(\.[cm]?)js$/, '$1ts')}`)
+require(binPath)

package/bin-helper/index.d.cts

@@ -0,0 +1 @@
+export {}

package/bin-helper/index.d.ts

@@ -0,0 +1 @@
+export {}

package/bin-helper/package.json

@@ -1 +1,5 @@
-{"type":"module","module":"../bin-helper.js","main":"../bin-helper.cjs"}
+{
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js"
+}

package/dist/.internal/+/bin/parseArgv.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var commander = require('commander');
+var process = require('node:process');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var process__default = /*#__PURE__*/_interopDefault(process);
+
+const { argv } = process__default.default;
+const env = {};
+let isPassThrough = false;
+const newArgv = argv.filter((arg) => {
+  if (isPassThrough) {
+    return true;
+  }
+  if (arg === "--") {
+    isPassThrough = true;
+    return false;
+  }
+  const m = /^--env\.(\w+)=(.*)$/.exec(arg);
+  if (m) {
+    env[m[1]] = m[2];
+    return false;
+  }
+  return true;
+});
+for (const [key, value] of Object.entries(env)) {
+  process__default.default.env[key] = value;
+}
+var parseArgv = () => commander.program.parse(newArgv);
+
+module.exports = parseArgv;

package/dist/.internal/+/bin/parseArgv.d.cts

@@ -0,0 +1,5 @@
+import * as commander from 'commander';
+
+declare const _default: () => commander.Command;
+
+export { _default as default };

package/dist/.internal/+/bin/parseArgv.d.ts

@@ -0,0 +1,5 @@
+import * as commander from 'commander';
+
+declare const _default: () => commander.Command;
+
+export { _default as default };

package/dist/.internal/+/bin/parseArgv.js

@@ -0,0 +1,27 @@
+import { program } from 'commander';
+import process from 'node:process';
+
+const { argv } = process;
+const env = {};
+let isPassThrough = false;
+const newArgv = argv.filter((arg) => {
+  if (isPassThrough) {
+    return true;
+  }
+  if (arg === "--") {
+    isPassThrough = true;
+    return false;
+  }
+  const m = /^--env\.(\w+)=(.*)$/.exec(arg);
+  if (m) {
+    env[m[1]] = m[2];
+    return false;
+  }
+  return true;
+});
+for (const [key, value] of Object.entries(env)) {
+  process.env[key] = value;
+}
+var parseArgv = () => program.parse(newArgv);
+
+export { parseArgv as default };

package/dist/.internal/+/bridge.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var execa = require('execa');
+
+const bridgeDisabledRef = { value: false };
+const publish = async (type, data) => {
+  if (bridgeDisabledRef.value) return Promise.resolve();
+  return execa.sendMessage({ type, data });
+};
+
+exports.bridgeDisabledRef = bridgeDisabledRef;
+exports.publish = publish;

package/dist/.internal/+/bridge.d.cts

@@ -0,0 +1,39 @@
+import { Module } from './rollup/bundle-analyzer.cjs';
+import 'rollup';
+import 'vite-bundle-analyzer';
+
+declare const bridgeDisabledRef: {
+    value: boolean;
+};
+interface RollupBuildEntryCtx {
+    type: 'esm' | 'cjs';
+    name: string;
+    path: string;
+    exportConditions: string[];
+    input: string;
+}
+interface RollupBuildEventMap {
+    init: {
+        leafMap: Map<string, string[][]>;
+        targetsLength: number;
+    };
+    progress: RollupBuildEntryCtx & {
+        tags?: string[];
+        event?: string;
+        message?: string;
+    };
+    watchChange: RollupBuildEntryCtx & {
+        id: string;
+    };
+    modulesAnalyze: RollupBuildEntryCtx & {
+        modules: Module[];
+    };
+    debug: unknown;
+}
+type RollupBuildEvent = keyof RollupBuildEventMap extends infer K ? K extends infer Item extends keyof RollupBuildEventMap ? {
+    type: Item;
+    data: RollupBuildEventMap[Item];
+} : never : never;
+declare const publish: <K extends keyof RollupBuildEventMap>(type: K, data: RollupBuildEventMap[K]) => Promise<void>;
+
+export { type RollupBuildEntryCtx, type RollupBuildEvent, type RollupBuildEventMap, bridgeDisabledRef, publish };

package/dist/.internal/+/bridge.d.ts

@@ -0,0 +1,39 @@
+import { Module } from './rollup/bundle-analyzer.js';
+import 'rollup';
+import 'vite-bundle-analyzer';
+
+declare const bridgeDisabledRef: {
+    value: boolean;
+};
+interface RollupBuildEntryCtx {
+    type: 'esm' | 'cjs';
+    name: string;
+    path: string;
+    exportConditions: string[];
+    input: string;
+}
+interface RollupBuildEventMap {
+    init: {
+        leafMap: Map<string, string[][]>;
+        targetsLength: number;
+    };
+    progress: RollupBuildEntryCtx & {
+        tags?: string[];
+        event?: string;
+        message?: string;
+    };
+    watchChange: RollupBuildEntryCtx & {
+        id: string;
+    };
+    modulesAnalyze: RollupBuildEntryCtx & {
+        modules: Module[];
+    };
+    debug: unknown;
+}
+type RollupBuildEvent = keyof RollupBuildEventMap extends infer K ? K extends infer Item extends keyof RollupBuildEventMap ? {
+    type: Item;
+    data: RollupBuildEventMap[Item];
+} : never : never;
+declare const publish: <K extends keyof RollupBuildEventMap>(type: K, data: RollupBuildEventMap[K]) => Promise<void>;
+
+export { type RollupBuildEntryCtx, type RollupBuildEvent, type RollupBuildEventMap, bridgeDisabledRef, publish };

package/dist/.internal/+/bridge.js

@@ -0,0 +1,9 @@
+import { sendMessage } from 'execa';
+
+const bridgeDisabledRef = { value: false };
+const publish = async (type, data) => {
+  if (bridgeDisabledRef.value) return Promise.resolve();
+  return sendMessage({ type, data });
+};
+
+export { bridgeDisabledRef, publish };

package/dist/.internal/+/commands/build/analyzer.cjs

@@ -0,0 +1,201 @@
+'use strict';
+
+var optionParser = require('../utils/optionParser.cjs');
+var checkDependency = require('../../utils/checkDependency.cjs');
+var fs = require('node:fs');
+var path = require('node:path');
+require('../../../jiek_create-require-CWFWNQHj.js');
+require('node:child_process');
+require('node:process');
+require('@inquirer/prompts');
+require('../../../getWD-BRJ3PK1S.js');
+require('@jiek/utils/getWorkspaceDir');
+require('commander');
+require('js-yaml');
+require('../../utils/getRoot.cjs');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+function Main() {
+  const { useState, useMemo, useEffect, useCallback } = React;
+  const [path, setPath] = useState(() => location.pathname.replace(/^\/ana\/?/, ""));
+  const [pkgName, entry] = useMemo(() => {
+    const pkgName2 = /^(@[^/]+\/[^/]+|[^/]+)\/?/.exec(path)?.[1];
+    return [
+      pkgName2,
+      pkgName2 != null ? path.replace(`${pkgName2}/`, "") : void 0
+    ];
+  }, [path]);
+  const push = useCallback((newPath) => {
+    setPath(newPath);
+    document.title = `${document.title.replace(/ - \/.*/, "")} - /${newPath}`;
+    history.pushState(null, "", `/ana/${newPath}`);
+  }, []);
+  const filterModules = useCallback((startWith) => {
+    const modules = analyzeModule.filter((m) => m.filename.startsWith(startWith));
+    dispatchEvent(new CustomEvent("send:filter", { detail: { analyzeModule: modules } }));
+  }, []);
+  useEffect(() => {
+    if (path !== "") {
+      document.title = `${document.title.replace(/ - \/.*/, "")} - /${path}`;
+    } else {
+      document.title = document.title.replace(/ - \/.*/, "");
+    }
+    filterModules(path);
+  }, [path, filterModules]);
+  useEffect(() => {
+    const offGraphClick = listen("graph:click", ({ detail }) => {
+      if (!detail) return;
+      let root = detail.node;
+      while (root.parent) {
+        root = root.parent;
+      }
+      if (root.filename === path) return;
+      push(root.filename);
+    });
+    return () => {
+      offGraphClick();
+    };
+  }, [push]);
+  function listen(type, listener) {
+    window.addEventListener(type, listener);
+    return () => {
+      window.removeEventListener(type, listener);
+    };
+  }
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      style: {
+        padding: "12px 55px"
+      }
+    },
+    "/",
+    /* @__PURE__ */ React.createElement(
+      "select",
+      {
+        style: {
+          appearance: "none",
+          border: "none",
+          background: "none"
+        },
+        value: pkgName,
+        onChange: (e) => push(e.target.value)
+      },
+      /* @__PURE__ */ React.createElement("option", { value: "" }, "All"),
+      analyzeModule.map((m) => /^(@[^/]+\/[^/]+|[^/]+)\/?/.exec(m.filename)?.[1]).filter((v, i, a) => a.indexOf(v) === i).map((v) => /* @__PURE__ */ React.createElement("option", { key: v, value: v }, v))
+    ),
+    pkgName != null && /* @__PURE__ */ React.createElement(React.Fragment, null, "/", /* @__PURE__ */ React.createElement(
+      "select",
+      {
+        style: {
+          appearance: "none",
+          border: "none",
+          background: "none"
+        },
+        value: entry,
+        onChange: (e) => push(`${pkgName}/${e.target.value}`)
+      },
+      /* @__PURE__ */ React.createElement("option", { value: "" }, "All"),
+      analyzeModule.filter((m) => m.filename.startsWith(`${pkgName}/`)).map((m) => m.filename.replace(`${pkgName}/`, "")).filter((v, i, a) => a.indexOf(v) === i).map((v) => /* @__PURE__ */ React.createElement("option", { key: v, value: v }, v))
+    ))
+  );
+}
+
+function render() {
+  CUSTOM_SIDE_BAR = true;
+  window.addEventListener("client:ready", () => window.dispatchEvent(
+    new CustomEvent("send:ui", {
+      detail: { type: "Main", Component: __REPLACE_INJECT__ }
+    })
+  ));
+}
+const CLIENT_CUSTOM_RENDER_SCRIPT = [
+  Main.toString(),
+  render.toString().replace("__REPLACE_INJECT__", Main.name),
+  `(${render.name})()`
+].join("\n");
+
+const registerAnalyzerCommandOptions = (command) => command.option("--ana", "Enable the bundle analyzer.", optionParser.parseBoolean).option("--ana.dir <DIR>", "The directory of the bundle analyzer.", ".jk-analyses").option(
+  "--ana.mode <MODE>",
+  'The mode of the bundle analyzer, support "static", "json" and "server".',
+  "server"
+).option("--ana.open", "Open the bundle analyzer in the browser.", optionParser.parseBoolean).option(
+  "--ana.size <SIZE>",
+  'The default size of the bundle analyzer, support "stat", "parsed" and "gzip".',
+  "parsed"
+);
+const useAnalyzer = async (options, server) => {
+  const modules = [];
+  let bundleAnalyzerModule;
+  const analyzer = options.ana ? {
+    dir: options["ana.dir"],
+    mode: options["ana.mode"],
+    open: options["ana.open"],
+    size: options["ana.size"]
+  } : void 0;
+  if (options.ana && ![
+    "stat",
+    "parsed",
+    "gzip"
+  ].includes(analyzer?.size ?? "")) {
+    throw new Error('The value of `ana.size` must be "stat", "parsed" or "gzip"');
+  }
+  if (analyzer) {
+    await checkDependency.checkDependency("vite-bundle-analyzer");
+    bundleAnalyzerModule = await import('vite-bundle-analyzer');
+  }
+  const refreshAnalyzer = async (cwd, applyModules) => {
+    if (!(analyzer && server && bundleAnalyzerModule)) return;
+    if (analyzer.mode === "json") {
+      const anaDir = path__default.default.resolve(cwd, analyzer.dir);
+      if (!fs.existsSync(anaDir)) {
+        fs.mkdirSync(anaDir, { recursive: true });
+      }
+      const gitIgnorePath = path__default.default.resolve(anaDir, ".gitignore");
+      if (!fs.existsSync(gitIgnorePath)) {
+        fs.writeFileSync(gitIgnorePath, "*\n!.gitignore\n");
+      }
+      const npmIgnorePath = path__default.default.resolve(anaDir, ".npmignore");
+      if (!fs.existsSync(npmIgnorePath)) {
+        fs.writeFileSync(npmIgnorePath, "*\n");
+      }
+      if (!fs.statSync(anaDir).isDirectory()) {
+        throw new Error(`The directory '${anaDir}' is not a directory.`);
+      }
+    }
+    const { renderView, injectHTMLTag } = bundleAnalyzerModule;
+    applyModules.forEach((m) => {
+      const index = modules.findIndex(({ filename }) => filename === m.filename);
+      if (index === -1) {
+        modules.push(m);
+      } else {
+        modules[index] = m;
+      }
+    });
+    let html = await renderView(modules, {
+      title: `Jiek Analyzer`,
+      mode: analyzer.size
+    });
+    html = injectHTMLTag({
+      html,
+      injectTo: "body",
+      descriptors: [
+        { kind: "script", text: CLIENT_CUSTOM_RENDER_SCRIPT }
+      ]
+    });
+    void server.renderTo("/ana", html);
+  };
+  return {
+    modules,
+    refreshAnalyzer,
+    ANALYZER_ENV: {
+      JIEK_ANALYZER: analyzer ? JSON.stringify(analyzer) : void 0
+    }
+  };
+};
+
+exports.registerAnalyzerCommandOptions = registerAnalyzerCommandOptions;
+exports.useAnalyzer = useAnalyzer;

package/dist/.internal/+/commands/build/analyzer.d.cts

@@ -0,0 +1,30 @@
+import * as vite_bundle_analyzer from 'vite-bundle-analyzer';
+import { Command } from 'commander';
+import { createServer } from '../../server.cjs';
+
+interface AnalyzerBuildOptions {
+    ana?: boolean;
+    /**
+     * @default '.jk-analyses'
+     */
+    'ana.dir': string;
+    /**
+     * @default 'server'
+     */
+    'ana.mode': string;
+    'ana.open'?: boolean;
+    /**
+     * @default 'parsed'
+     */
+    'ana.size': string;
+}
+declare const registerAnalyzerCommandOptions: (command: Command) => Command;
+declare const useAnalyzer: (options: AnalyzerBuildOptions, server?: ReturnType<typeof createServer>) => Promise<{
+    modules: vite_bundle_analyzer.Module[];
+    refreshAnalyzer: (cwd: string, applyModules: vite_bundle_analyzer.Module[]) => Promise<void>;
+    ANALYZER_ENV: {
+        JIEK_ANALYZER: string | undefined;
+    };
+}>;
+
+export { type AnalyzerBuildOptions, registerAnalyzerCommandOptions, useAnalyzer };

package/dist/.internal/+/commands/build/analyzer.d.ts

@@ -0,0 +1,30 @@
+import * as vite_bundle_analyzer from 'vite-bundle-analyzer';
+import { Command } from 'commander';
+import { createServer } from '../../server.js';
+
+interface AnalyzerBuildOptions {
+    ana?: boolean;
+    /**
+     * @default '.jk-analyses'
+     */
+    'ana.dir': string;
+    /**
+     * @default 'server'
+     */
+    'ana.mode': string;
+    'ana.open'?: boolean;
+    /**
+     * @default 'parsed'
+     */
+    'ana.size': string;
+}
+declare const registerAnalyzerCommandOptions: (command: Command) => Command;
+declare const useAnalyzer: (options: AnalyzerBuildOptions, server?: ReturnType<typeof createServer>) => Promise<{
+    modules: vite_bundle_analyzer.Module[];
+    refreshAnalyzer: (cwd: string, applyModules: vite_bundle_analyzer.Module[]) => Promise<void>;
+    ANALYZER_ENV: {
+        JIEK_ANALYZER: string | undefined;
+    };
+}>;
+
+export { type AnalyzerBuildOptions, registerAnalyzerCommandOptions, useAnalyzer };