unplugin-dingtalk 0.1.1

package/dist/nuxt.cjs

@@ -0,0 +1,350 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/.pnpm/picocolors@1.0.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "node_modules/.pnpm/picocolors@1.0.1/node_modules/picocolors/picocolors.js"(exports2, module2) {
+    "use strict";
+    var argv = process.argv || [];
+    var env = process.env;
+    var isColorSupported = !("NO_COLOR" in env || argv.includes("--no-color")) && ("FORCE_COLOR" in env || argv.includes("--color") || process.platform === "win32" || require != null && require("tty").isatty(1) && env.TERM !== "dumb" || "CI" in env);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input;
+      let index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "";
+      let cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let init = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: init("\x1B[0m", "\x1B[0m"),
+        bold: init("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: init("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: init("\x1B[3m", "\x1B[23m"),
+        underline: init("\x1B[4m", "\x1B[24m"),
+        inverse: init("\x1B[7m", "\x1B[27m"),
+        hidden: init("\x1B[8m", "\x1B[28m"),
+        strikethrough: init("\x1B[9m", "\x1B[29m"),
+        black: init("\x1B[30m", "\x1B[39m"),
+        red: init("\x1B[31m", "\x1B[39m"),
+        green: init("\x1B[32m", "\x1B[39m"),
+        yellow: init("\x1B[33m", "\x1B[39m"),
+        blue: init("\x1B[34m", "\x1B[39m"),
+        magenta: init("\x1B[35m", "\x1B[39m"),
+        cyan: init("\x1B[36m", "\x1B[39m"),
+        white: init("\x1B[37m", "\x1B[39m"),
+        gray: init("\x1B[90m", "\x1B[39m"),
+        bgBlack: init("\x1B[40m", "\x1B[49m"),
+        bgRed: init("\x1B[41m", "\x1B[49m"),
+        bgGreen: init("\x1B[42m", "\x1B[49m"),
+        bgYellow: init("\x1B[43m", "\x1B[49m"),
+        bgBlue: init("\x1B[44m", "\x1B[49m"),
+        bgMagenta: init("\x1B[45m", "\x1B[49m"),
+        bgCyan: init("\x1B[46m", "\x1B[49m"),
+        bgWhite: init("\x1B[47m", "\x1B[49m")
+      };
+    };
+    module2.exports = createColors();
+    module2.exports.createColors = createColors;
+  }
+});
+
+// src/nuxt.ts
+var nuxt_exports = {};
+__export(nuxt_exports, {
+  default: () => nuxt_default
+});
+module.exports = __toCommonJS(nuxt_exports);
+var import_kit = require("@nuxt/kit");
+
+// src/vite.ts
+var import_unplugin2 = require("unplugin");
+
+// src/index.ts
+var import_node_child_process = require("child_process");
+var import_node_process = __toESM(require("process"), 1);
+var import_unplugin = require("unplugin");
+var import_picocolors = __toESM(require_picocolors(), 1);
+
+// node_modules/.pnpm/vite-plugin-vconsole@2.1.1/node_modules/vite-plugin-vconsole/dist/main.mjs
+var parseVConsoleOptions = (config2) => Object.keys(config2).reduce((code, key) => {
+  const value = config2[key];
+  if (typeof value === "function") {
+    if (/^[(f]/.test(value.toString())) {
+      code += `${key}: ${value},`;
+      return code;
+    } else {
+      code += `${value},`;
+      return code;
+    }
+  }
+  code += `${key}: ${JSON.stringify(config2[key])},`;
+  return code;
+}, "");
+var getEventItems = (event, id) => {
+  return event.map(
+    (ele) => `
+    ${id}.on('${ele.eventName}', ${ele.callback})
+    `
+  ).join(";");
+};
+var getDynamicConfig = (dynamicConfig) => {
+  let configString = "";
+  if (!dynamicConfig) {
+    return configString;
+  }
+  for (const key in dynamicConfig) {
+    if (typeof dynamicConfig[key] === "string") {
+      configString += `${key}: ${dynamicConfig[key]},`;
+    }
+  }
+  return configString;
+};
+var getPlugins = (plugin) => {
+  let plugins = "";
+  if (plugin && plugin.length) {
+    plugins = plugin.map(
+      (e) => `
+    const ${e.id} = new VConsole.VConsolePlugin('${e.id}', '${e.name}');
+    ${getEventItems(e.event, e.id)}
+    vConsole.addPlugin(${e.id})
+    `
+    ).join(";");
+  }
+  return plugins;
+};
+function viteVConsole(opt) {
+  const {
+    entry,
+    enabled = true,
+    config: config2 = {},
+    plugin,
+    customHide = false,
+    dynamicConfig = {},
+    eventListener = ""
+  } = opt;
+  let entryPath = Array.isArray(entry) ? entry : [entry];
+  if (process.platform === "win32")
+    entryPath = entryPath.map((item) => item.replace(/\\/g, "/"));
+  const enabledTruly = enabled;
+  return {
+    name: "vite:vconsole",
+    enforce: "pre",
+    transform(_source, id) {
+      if (entryPath.includes(id) && enabledTruly) {
+        const code = `/* eslint-disable */;
+        import VConsole from 'vconsole';
+        // config
+        const vConsole = new VConsole({${parseVConsoleOptions(
+          config2
+        )}});
+        window.vConsole = vConsole;
+
+        // plugins
+        ${getPlugins(plugin)}
+
+        // dynamic config
+        window.vConsole.dynamicFunction = function() {
+          if (${getDynamicConfig(dynamicConfig).length > 0}) {
+            vConsole.setOption({${getDynamicConfig(dynamicConfig)}});
+          }
+        };
+        
+        window.vConsole.dynamicChange = {
+          value: new Date().getTime()
+        };
+
+        window.vConsole.dynamicFunction();
+
+        if (${customHide}) {
+          vConsole.hideSwitch();
+        }
+
+        // In order to be compatible with old equipment, I used defineProperty. In the future, when proxy covers enough devices, proxy will be used.
+        Object.defineProperty(window.vConsole.dynamicChange, 'value', {
+          get: function() {
+            return this._value;
+          },
+          set: function(newValue) {
+            window.vConsole.dynamicFunction();
+            this._value = newValue;
+          }
+        });
+
+        // eventListener
+        ${eventListener}
+        /* eslint-enable */${_source}`;
+        return {
+          code,
+          map: null
+          // support source map
+        };
+      }
+      return {
+        code: _source,
+        map: null
+        // support source map
+      };
+    }
+  };
+}
+
+// src/index.ts
+var config;
+var devtoolsInstance;
+var colorUrl = (url) => import_picocolors.default.green(url.replace(/:(\d+)\//, (_, port) => `:${import_picocolors.default.bold(port)}/`));
+var unpluginFactory = (options) => {
+  var _a;
+  const unpluginDing = {
+    name: "unplugin-dingtalk",
+    enforce: "pre",
+    transformInclude(id) {
+      return id.endsWith("main.ts") || id.endsWith("main.js");
+    },
+    transform(_source) {
+      var _a2, _b, _c;
+      if ((_a2 = options == null ? void 0 : options.vueDevtools) == null ? void 0 : _a2.enable) {
+        const code = `/* eslint-disable */;
+        import { devtools } from '@vue/devtools'
+        devtools.connect(${(_b = options == null ? void 0 : options.vueDevtools) == null ? void 0 : _b.host}, ${(_c = options == null ? void 0 : options.vueDevtools) == null ? void 0 : _c.port})
+        /* eslint-enable */${_source};
+        `;
+        return {
+          code,
+          map: null
+          // support source map
+        };
+      }
+      return {
+        code: _source,
+        map: null
+        // support source map
+      };
+    },
+    vite: {
+      configResolved(_config) {
+        config = _config;
+      },
+      configureServer(server) {
+        var _a2, _b;
+        if (!(options == null ? void 0 : options.enable)) {
+          return;
+        }
+        function debug(...args) {
+          if (options == null ? void 0 : options.debug) {
+            console.log(`  ${import_picocolors.default.yellow("DEBUG")}  `, ...args);
+          }
+        }
+        const _printUrls = server.printUrls.bind(server);
+        let source = `localhost:${config.server.port || 5173}`;
+        const url = (_a2 = server.resolvedUrls) == null ? void 0 : _a2.local[0];
+        if (url) {
+          const u = new URL(url);
+          source = u.host;
+        }
+        const base = server.config.base || "/";
+        const _targetUrl = (_b = options == null ? void 0 : options.targetUrl) != null ? _b : `http://${source}${base}`;
+        server.printUrls = () => {
+          var _a3;
+          _printUrls();
+          console.log(`  ${import_picocolors.default.green("\u279C")}  ${import_picocolors.default.bold(
+            `Open in dingtalk${((_a3 = options == null ? void 0 : options.vueDevtools) == null ? void 0 : _a3.enable) ? " (with vue-devtools)" : ""}`
+          )}: ${colorUrl(`http://${source}${base}open-dingtalk`)}`);
+        };
+        const targetURL = new URL(_targetUrl);
+        targetURL.searchParams.append("ddtab", "true");
+        if (options == null ? void 0 : options.corpId) {
+          targetURL.searchParams.append("corpId", options.corpId);
+        }
+        server.middlewares.use("/open-dingtalk", (req, res) => {
+          var _a3;
+          debug(targetURL.toString());
+          res.writeHead(302, {
+            Location: `dingtalk://dingtalkclient/page/link?url=${encodeURIComponent(targetURL.toString())}`
+          });
+          if (((_a3 = options == null ? void 0 : options.vueDevtools) == null ? void 0 : _a3.enable) && !devtoolsInstance) {
+            devtoolsInstance = (0, import_node_child_process.exec)("npx vue-devtools");
+            console.log(`  ${import_picocolors.default.green("\u279C")}  vue-devtools is running. If the devtools has no data, please refresh the page in dingtalk.`);
+            devtoolsInstance.on("exit", () => {
+              devtoolsInstance = void 0;
+            });
+            import_node_process.default.on("exit", () => {
+              if (devtoolsInstance) {
+                devtoolsInstance.kill();
+              }
+            });
+          }
+          res.end();
+        });
+      }
+    }
+  };
+  if ((options == null ? void 0 : options.enable) && ((_a = options == null ? void 0 : options.vconsole) == null ? void 0 : _a.enabled)) {
+    return [viteVConsole(options == null ? void 0 : options.vconsole), unpluginDing];
+  } else {
+    return unpluginDing;
+  }
+};
+
+// src/vite.ts
+var vite_default = (0, import_unplugin2.createVitePlugin)(unpluginFactory);
+
+// src/webpack.ts
+var import_unplugin3 = require("unplugin");
+var webpack_default = (0, import_unplugin3.createWebpackPlugin)(unpluginFactory);
+
+// src/nuxt.ts
+var import_schema = require("@nuxt/schema");
+var nuxt_default = (0, import_kit.defineNuxtModule)({
+  meta: {
+    name: "nuxt-unplugin-dingtalk",
+    configKey: "unpluginStarter"
+  },
+  defaults: {
+    // ...default options
+  },
+  setup(options, _nuxt) {
+    (0, import_kit.addVitePlugin)(() => vite_default(options));
+    (0, import_kit.addWebpackPlugin)(() => webpack_default(options));
+  }
+});
+exports.default = module.exports;

package/dist/nuxt.d.cts

@@ -0,0 +1,9 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { Options } from './types.cjs';
+import 'vite-plugin-vconsole';
+
+interface ModuleOptions extends Options {
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+export { type ModuleOptions, _default as default };

package/dist/nuxt.d.ts

@@ -0,0 +1,9 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { Options } from './types.js';
+import 'vite-plugin-vconsole';
+
+interface ModuleOptions extends Options {
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+export { type ModuleOptions, _default as default };

package/dist/nuxt.js

@@ -0,0 +1,27 @@
+import {
+  webpack_default
+} from "./chunk-KYZ5HD2N.js";
+import {
+  vite_default
+} from "./chunk-NRP2YPPZ.js";
+import "./chunk-I4UPMGWK.js";
+
+// src/nuxt.ts
+import { addVitePlugin, addWebpackPlugin, defineNuxtModule } from "@nuxt/kit";
+import "@nuxt/schema";
+var nuxt_default = defineNuxtModule({
+  meta: {
+    name: "nuxt-unplugin-dingtalk",
+    configKey: "unpluginStarter"
+  },
+  defaults: {
+    // ...default options
+  },
+  setup(options, _nuxt) {
+    addVitePlugin(() => vite_default(options));
+    addWebpackPlugin(() => webpack_default(options));
+  }
+});
+export {
+  nuxt_default as default
+};