vite-plugin-vue-devtools 0.0.1-alpha.0 → 0.0.1-alpha.2

package/dist/client/assets/rpc-c07563d7.js

@@ -0,0 +1,136 @@
+import { aC as __vitePreload } from './index-ab9e9151.js';
+
+const DEFAULT_TIMEOUT = 6e4;
+function defaultSerialize(i) {
+  return i;
+}
+const defaultDeserialize = defaultSerialize;
+const { setTimeout } = globalThis;
+function createBirpc(functions, options) {
+  const {
+    post,
+    on,
+    eventNames = [],
+    serialize = defaultSerialize,
+    deserialize = defaultDeserialize,
+    resolver,
+    timeout = DEFAULT_TIMEOUT
+  } = options;
+  const rpcPromiseMap = /* @__PURE__ */ new Map();
+  let _promise;
+  const rpc = new Proxy({}, {
+    get(_, method) {
+      if (method === "$functions")
+        return functions;
+      const sendEvent = (...args) => {
+        post(serialize({ m: method, a: args, t: "q" }));
+      };
+      if (eventNames.includes(method)) {
+        sendEvent.asEvent = sendEvent;
+        return sendEvent;
+      }
+      const sendCall = async (...args) => {
+        await _promise;
+        return new Promise((resolve, reject) => {
+          const id = nanoid();
+          rpcPromiseMap.set(id, { resolve, reject });
+          post(serialize({ m: method, a: args, i: id, t: "q" }));
+          if (timeout >= 0) {
+            setTimeout(() => {
+              reject(new Error(`[birpc] timeout on calling "${method}"`));
+              rpcPromiseMap.delete(id);
+            }, timeout);
+          }
+        });
+      };
+      sendCall.asEvent = sendEvent;
+      return sendCall;
+    }
+  });
+  _promise = on(async (data, ...extra) => {
+    const msg = deserialize(data);
+    if (msg.t === "q") {
+      const { m: method, a: args } = msg;
+      let result, error;
+      const fn = resolver ? resolver(method, functions[method]) : functions[method];
+      if (!fn) {
+        error = new Error(`[birpc] function "${method}" not found`);
+      } else {
+        try {
+          result = await fn.apply(rpc, args);
+        } catch (e) {
+          error = e;
+        }
+      }
+      if (msg.i) {
+        if (error && options.onError)
+          options.onError(error, method, args);
+        post(serialize({ t: "s", i: msg.i, r: result, e: error }), ...extra);
+      }
+    } else {
+      const { i: ack, r: result, e: error } = msg;
+      const promise = rpcPromiseMap.get(ack);
+      if (promise) {
+        if (error)
+          promise.reject(error);
+        else
+          promise.resolve(result);
+      }
+      rpcPromiseMap.delete(ack);
+    }
+  });
+  return rpc;
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+  let id = "";
+  let i = size;
+  while (i--)
+    id += urlAlphabet[Math.random() * 64 | 0];
+  return id;
+}
+
+/* Injected with object hook! */
+
+function createRPCClient(name, hot, functions = {}) {
+  const event = `${name}:rpc`;
+  return createBirpc(
+    functions,
+    {
+      on: async (fn) => {
+        (await hot).on(event, fn);
+      },
+      post: async (data) => {
+        (await hot).send(event, data);
+      }
+    }
+  );
+}
+
+/* Injected with object hook! */
+
+async function getViteClient(base = "/", warning = true) {
+  try {
+    return await __vitePreload(() => import(
+      /* @vite-ignore */
+      `${base}@vite/client`
+    ),true?[]:void 0,import.meta.url);
+  } catch {
+    if (warning)
+      console.error(`[vite-plugin-hot] Failed to import "${base}@vite/client"`);
+  }
+  return void 0;
+}
+async function createHotContext(path = "/____", base = "/") {
+  const viteClient = await getViteClient(base);
+  return viteClient?.createHotContext(path);
+}
+
+/* Injected with object hook! */
+
+const rpc = createRPCClient("vite-plugin-vue-devtools", await createHotContext("/___", `${location.pathname.split("/__devtools")[0] || ""}/`.replace(/\/\//g, "/")));
+const inspectClientUrl = await rpc.inspectClientUrl();
+
+/* Injected with object hook! */
+
+export { inspectClientUrl as i, rpc as r };

package/dist/client/assets/settings-c9f4467d.js

@@ -0,0 +1,299 @@
+import { _ as _sfc_main$3 } from './VIcon.vue_vue_type_script_setup_true_lang-c622c694.js';
+import { d as defineComponent, s as useVModel, o as openBlock, c as createElementBlock, v as renderSlot, x as withDirectives, y as vModelSelect, u as unref, e as createBaseVNode, t as toDisplayString, m as createCommentVNode, z as isRef, a as createBlock, A as vModelCheckbox, B as withKeys, C as useTabs, D as useCategorizedTabs, b as createVNode, F as Fragment, r as renderList, w as withCtx, E as createTextVNode, G as useDevToolsSettings, _ as _sfc_main$5, H as _sfc_main$6, n as normalizeClass, I as _sfc_main$7 } from './index-ab9e9151.js';
+import { _ as _sfc_main$4 } from './VIconTitle.vue_vue_type_script_setup_true_lang-5f26c7d7.js';
+
+const _hoisted_1$2 = { class: "n-text-input flex flex items-center border n-border-base rounded px-2 py-1 focus-within:n-focus-base focus-within:border-context n-bg-base" };
+const _hoisted_2$2 = ["disabled"];
+const _hoisted_3$2 = {
+  key: 0,
+  value: "",
+  disabled: "",
+  hidden: ""
+};
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "VSelect",
+  props: {
+    modelValue: { default: void 0 },
+    placeholder: { default: "" },
+    icon: { default: "" },
+    disabled: { type: Boolean, default: false }
+  },
+  setup(__props, { emit }) {
+    const props = __props;
+    const input = useVModel(props, "modelValue", emit, { passive: true });
+    return (_ctx, _cache) => {
+      const _component_VIcon = _sfc_main$3;
+      return openBlock(), createElementBlock("div", _hoisted_1$2, [
+        renderSlot(_ctx.$slots, "icon", {}, () => [
+          __props.icon ? (openBlock(), createBlock(_component_VIcon, {
+            key: 0,
+            icon: __props.icon,
+            class: "mr-0.4em text-1.1em op50"
+          }, null, 8, ["icon"])) : createCommentVNode("", true)
+        ]),
+        withDirectives(createBaseVNode("select", {
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(input) ? input.value = $event : null),
+          disabled: __props.disabled,
+          class: "w-full flex-auto n-bg-base !outline-none"
+        }, [
+          __props.placeholder ? (openBlock(), createElementBlock("option", _hoisted_3$2, toDisplayString(__props.placeholder), 1)) : createCommentVNode("", true),
+          renderSlot(_ctx.$slots, "default")
+        ], 8, _hoisted_2$2), [
+          [vModelSelect, unref(input)]
+        ])
+      ]);
+    };
+  }
+});
+
+/* Injected with object hook! */
+
+const _hoisted_1$1 = ["checked", "disabled"];
+const _hoisted_2$1 = ["disabled"];
+const _hoisted_3$1 = /* @__PURE__ */ createBaseVNode("div", { class: "n-switch-slider n-checked:n-switch-slider-checked peer-active:n-active-base peer-focus-visible:n-focus-base n-transition" }, [
+  /* @__PURE__ */ createBaseVNode("div", { class: "n-checked:n-switch-thumb-checked n-switch-thumb n-transition" })
+], -1);
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "VSwitch",
+  props: {
+    modelValue: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false }
+  },
+  setup(__props, { emit }) {
+    const props = __props;
+    const checked = useVModel(props, "modelValue", emit, { passive: true });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("label", {
+        class: "n-switch n-switch-base n-disabled:n-disabled",
+        checked: unref(checked) || null,
+        disabled: __props.disabled || null
+      }, [
+        withDirectives(createBaseVNode("input", {
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(checked) ? checked.value = $event : null),
+          type: "checkbox",
+          class: "peer absolute op0",
+          disabled: __props.disabled,
+          onKeypress: _cache[1] || (_cache[1] = withKeys(($event) => checked.value = !unref(checked), ["enter"]))
+        }, null, 40, _hoisted_2$1), [
+          [vModelCheckbox, unref(checked)]
+        ]),
+        _hoisted_3$1,
+        renderSlot(_ctx.$slots, "default")
+      ], 8, _hoisted_1$1);
+    };
+  }
+});
+
+/* Injected with object hook! */
+
+const _hoisted_1 = {
+  "overflow-scroll": "",
+  px6: "",
+  py6: ""
+};
+const _hoisted_2 = {
+  grid: "~ md:cols-2 gap-x-10 gap-y-3",
+  "max-w-300": ""
+};
+const _hoisted_3 = {
+  flex: "~ col gap-1",
+  py3: ""
+};
+const _hoisted_4 = /* @__PURE__ */ createBaseVNode("h3", {
+  mb1: "",
+  "text-lg": ""
+}, " Tabs ", -1);
+const _hoisted_5 = {
+  flex: "~ gap-2",
+  "flex-auto": "",
+  "items-center": "",
+  "justify-start": ""
+};
+const _hoisted_6 = {
+  capitalize: "",
+  op75: ""
+};
+const _hoisted_7 = {
+  flex: "~ col gap-1",
+  border: "~ base rounded",
+  py3: "",
+  pl4: "",
+  pr2: ""
+};
+const _hoisted_8 = {
+  py3: "",
+  flex: "~ col gap-1",
+  border: "b base"
+};
+const _hoisted_9 = /* @__PURE__ */ createBaseVNode("h3", {
+  mb1: "",
+  "text-lg": ""
+}, " Appearance ", -1);
+const _hoisted_10 = /* @__PURE__ */ createBaseVNode("div", {
+  "carbon-sun": "",
+  "dark:carbon-moon": "",
+  "translate-y--1px": ""
+}, null, -1);
+const _hoisted_11 = {
+  py3: "",
+  flex: "~ col gap-1"
+};
+const _hoisted_12 = /* @__PURE__ */ createBaseVNode("h3", {
+  mb1: "",
+  "text-lg": ""
+}, " UI Scale ", -1);
+const _hoisted_13 = ["value"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "settings",
+  setup(__props) {
+    useTabs();
+    const {
+      scale,
+      hiddenTabs,
+      hiddenTabCategories
+    } = useDevToolsSettings();
+    const scaleOptions = [
+      ["Tiny", 12 / 15],
+      ["Small", 14 / 15],
+      ["Normal", 1],
+      ["Large", 16 / 15],
+      ["Huge", 18 / 15]
+    ];
+    const categories = useCategorizedTabs(false);
+    function toggleTab(name, v) {
+      if (v)
+        hiddenTabs.value = hiddenTabs.value.filter((i) => i !== name);
+      else
+        hiddenTabs.value.push(name);
+    }
+    function toggleTabCategory(name, v) {
+      if (v)
+        hiddenTabCategories.value = hiddenTabCategories.value.filter((i) => i !== name);
+      else
+        hiddenTabCategories.value.push(name);
+    }
+    return (_ctx, _cache) => {
+      const _component_VIconTitle = _sfc_main$4;
+      const _component_VSwitch = _sfc_main$1;
+      const _component_TabIcon = _sfc_main$7;
+      const _component_VButton = _sfc_main$5;
+      const _component_VDarkToggle = _sfc_main$6;
+      const _component_VSelect = _sfc_main$2;
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(_component_VIconTitle, {
+          class: "mb-5 text-xl op75",
+          icon: "i-carbon-settings",
+          text: "DevTools Settings"
+        }),
+        createBaseVNode("div", _hoisted_2, [
+          createBaseVNode("div", _hoisted_3, [
+            _hoisted_4,
+            (openBlock(true), createElementBlock(Fragment, null, renderList(unref(categories), ([name, tabs2]) => {
+              return openBlock(), createElementBlock(Fragment, { key: name }, [
+                tabs2.length ? (openBlock(), createElementBlock("div", {
+                  key: 0,
+                  flex: "~ col gap-1",
+                  "mx--1": "",
+                  class: normalizeClass(unref(hiddenTabCategories).includes(name) ? "op50 grayscale" : ""),
+                  "pt-2": ""
+                }, [
+                  createVNode(_component_VSwitch, {
+                    flex: "~ row-reverse",
+                    px2: "",
+                    py1: "",
+                    "n-lime": "",
+                    "model-value": !unref(hiddenTabCategories).includes(name),
+                    "onUpdate:modelValue": (v) => toggleTabCategory(name, v)
+                  }, {
+                    default: withCtx(() => [
+                      createBaseVNode("div", _hoisted_5, [
+                        createBaseVNode("span", _hoisted_6, toDisplayString(name), 1)
+                      ])
+                    ]),
+                    _: 2
+                  }, 1032, ["model-value", "onUpdate:modelValue"]),
+                  createBaseVNode("div", _hoisted_7, [
+                    (openBlock(true), createElementBlock(Fragment, null, renderList(tabs2, (tab) => {
+                      return openBlock(), createBlock(_component_VSwitch, {
+                        key: tab.name,
+                        flex: "~ row-reverse",
+                        py1: "",
+                        "n-primary": "",
+                        "model-value": !unref(hiddenTabs).includes(tab.title),
+                        "onUpdate:modelValue": (v) => toggleTab(tab.title, v)
+                      }, {
+                        default: withCtx(() => [
+                          createBaseVNode("div", {
+                            flex: "~ gap-2",
+                            "flex-auto": "",
+                            "items-center": "",
+                            "justify-start": "",
+                            class: normalizeClass(unref(hiddenTabs).includes(tab.title) ? "op25" : "")
+                          }, [
+                            createVNode(_component_TabIcon, {
+                              "text-xl": "",
+                              icon: tab.icon,
+                              title: tab.title
+                            }, null, 8, ["icon", "title"]),
+                            createBaseVNode("span", null, toDisplayString(tab.title), 1)
+                          ], 2)
+                        ]),
+                        _: 2
+                      }, 1032, ["model-value", "onUpdate:modelValue"]);
+                    }), 128))
+                  ])
+                ], 2)) : createCommentVNode("", true)
+              ], 64);
+            }), 128))
+          ]),
+          createBaseVNode("div", null, [
+            createBaseVNode("div", _hoisted_8, [
+              _hoisted_9,
+              createBaseVNode("div", null, [
+                createVNode(_component_VDarkToggle, null, {
+                  default: withCtx(({ toggle, isDark }) => [
+                    createVNode(_component_VButton, {
+                      n: "primary",
+                      onClick: ($event) => toggle()
+                    }, {
+                      default: withCtx(() => [
+                        _hoisted_10,
+                        createTextVNode(" " + toDisplayString(isDark.value ? "Dark" : "Light"), 1)
+                      ]),
+                      _: 2
+                    }, 1032, ["onClick"])
+                  ]),
+                  _: 1
+                })
+              ])
+            ]),
+            createBaseVNode("div", _hoisted_11, [
+              _hoisted_12,
+              createVNode(_component_VSelect, {
+                modelValue: unref(scale),
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(scale) ? scale.value = $event : null),
+                n: "primary"
+              }, {
+                default: withCtx(() => [
+                  (openBlock(), createElementBlock(Fragment, null, renderList(scaleOptions, (i) => {
+                    return createBaseVNode("option", {
+                      key: i[0],
+                      value: i[1]
+                    }, toDisplayString(i[0]), 9, _hoisted_13);
+                  }), 64))
+                ]),
+                _: 1
+              }, 8, ["modelValue"])
+            ])
+          ])
+        ])
+      ]);
+    };
+  }
+});
+
+/* Injected with object hook! */
+
+/* Injected with object hook! */
+
+export { _sfc_main as default };