@qwik.dev/devtools 0.2.1 → 0.2.2

package/dist/ui/node_modules/.pnpm/debug@4.4.3_supports-color@5.5.0/node_modules/debug/src/common.qwik.mjs

@@ -0,0 +1,182 @@
+import { __require as requireMs } from "../../../../ms@2.1.3/node_modules/ms/index.qwik.mjs";
+var common;
+var hasRequiredCommon;
+function requireCommon() {
+  if (hasRequiredCommon) return common;
+  hasRequiredCommon = 1;
+  function setup(env) {
+    createDebug.debug = createDebug;
+    createDebug.default = createDebug;
+    createDebug.coerce = coerce;
+    createDebug.disable = disable;
+    createDebug.enable = enable;
+    createDebug.enabled = enabled;
+    createDebug.humanize = requireMs();
+    createDebug.destroy = destroy;
+    Object.keys(env).forEach((key) => {
+      createDebug[key] = env[key];
+    });
+    createDebug.names = [];
+    createDebug.skips = [];
+    createDebug.formatters = {};
+    function selectColor(namespace) {
+      let hash = 0;
+      for (let i = 0; i < namespace.length; i++) {
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0;
+      }
+      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+    }
+    createDebug.selectColor = selectColor;
+    function createDebug(namespace) {
+      let prevTime;
+      let enableOverride = null;
+      let namespacesCache;
+      let enabledCache;
+      function debug(...args) {
+        if (!debug.enabled) {
+          return;
+        }
+        const self = debug;
+        const curr = Number(/* @__PURE__ */ new Date());
+        const ms = curr - (prevTime || curr);
+        self.diff = ms;
+        self.prev = prevTime;
+        self.curr = curr;
+        prevTime = curr;
+        args[0] = createDebug.coerce(args[0]);
+        if (typeof args[0] !== "string") {
+          args.unshift("%O");
+        }
+        let index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+          if (match === "%%") {
+            return "%";
+          }
+          index++;
+          const formatter = createDebug.formatters[format];
+          if (typeof formatter === "function") {
+            const val = args[index];
+            match = formatter.call(self, val);
+            args.splice(index, 1);
+            index--;
+          }
+          return match;
+        });
+        createDebug.formatArgs.call(self, args);
+        const logFn = self.log || createDebug.log;
+        logFn.apply(self, args);
+      }
+      debug.namespace = namespace;
+      debug.useColors = createDebug.useColors();
+      debug.color = createDebug.selectColor(namespace);
+      debug.extend = extend;
+      debug.destroy = createDebug.destroy;
+      Object.defineProperty(debug, "enabled", {
+        enumerable: true,
+        configurable: false,
+        get: () => {
+          if (enableOverride !== null) {
+            return enableOverride;
+          }
+          if (namespacesCache !== createDebug.namespaces) {
+            namespacesCache = createDebug.namespaces;
+            enabledCache = createDebug.enabled(namespace);
+          }
+          return enabledCache;
+        },
+        set: (v) => {
+          enableOverride = v;
+        }
+      });
+      if (typeof createDebug.init === "function") {
+        createDebug.init(debug);
+      }
+      return debug;
+    }
+    function extend(namespace, delimiter) {
+      const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+      newDebug.log = this.log;
+      return newDebug;
+    }
+    function enable(namespaces) {
+      createDebug.save(namespaces);
+      createDebug.namespaces = namespaces;
+      createDebug.names = [];
+      createDebug.skips = [];
+      const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+      for (const ns of split) {
+        if (ns[0] === "-") {
+          createDebug.skips.push(ns.slice(1));
+        } else {
+          createDebug.names.push(ns);
+        }
+      }
+    }
+    function matchesTemplate(search, template) {
+      let searchIndex = 0;
+      let templateIndex = 0;
+      let starIndex = -1;
+      let matchIndex = 0;
+      while (searchIndex < search.length) {
+        if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+          if (template[templateIndex] === "*") {
+            starIndex = templateIndex;
+            matchIndex = searchIndex;
+            templateIndex++;
+          } else {
+            searchIndex++;
+            templateIndex++;
+          }
+        } else if (starIndex !== -1) {
+          templateIndex = starIndex + 1;
+          matchIndex++;
+          searchIndex = matchIndex;
+        } else {
+          return false;
+        }
+      }
+      while (templateIndex < template.length && template[templateIndex] === "*") {
+        templateIndex++;
+      }
+      return templateIndex === template.length;
+    }
+    function disable() {
+      const namespaces = [
+        ...createDebug.names,
+        ...createDebug.skips.map((namespace) => "-" + namespace)
+      ].join(",");
+      createDebug.enable("");
+      return namespaces;
+    }
+    function enabled(name) {
+      for (const skip of createDebug.skips) {
+        if (matchesTemplate(name, skip)) {
+          return false;
+        }
+      }
+      for (const ns of createDebug.names) {
+        if (matchesTemplate(name, ns)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function coerce(val) {
+      if (val instanceof Error) {
+        return val.stack || val.message;
+      }
+      return val;
+    }
+    function destroy() {
+      console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+    }
+    createDebug.enable(createDebug.load());
+    return createDebug;
+  }
+  common = setup;
+  return common;
+}
+export {
+  requireCommon as __require
+};

package/dist/ui/node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.qwik.mjs

@@ -0,0 +1,120 @@
+var ms;
+var hasRequiredMs;
+function requireMs() {
+  if (hasRequiredMs) return ms;
+  hasRequiredMs = 1;
+  var s = 1e3;
+  var m = s * 60;
+  var h = m * 60;
+  var d = h * 24;
+  var w = d * 7;
+  var y = d * 365.25;
+  ms = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0) {
+      return parse(val);
+    } else if (type === "number" && isFinite(val)) {
+      return options.long ? fmtLong(val) : fmtShort(val);
+    }
+    throw new Error(
+      "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+    );
+  };
+  function parse(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
+    }
+    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+      str
+    );
+    if (!match) {
+      return;
+    }
+    var n = parseFloat(match[1]);
+    var type = (match[2] || "ms").toLowerCase();
+    switch (type) {
+      case "years":
+      case "year":
+      case "yrs":
+      case "yr":
+      case "y":
+        return n * y;
+      case "weeks":
+      case "week":
+      case "w":
+        return n * w;
+      case "days":
+      case "day":
+      case "d":
+        return n * d;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m;
+      case "seconds":
+      case "second":
+      case "secs":
+      case "sec":
+      case "s":
+        return n * s;
+      case "milliseconds":
+      case "millisecond":
+      case "msecs":
+      case "msec":
+      case "ms":
+        return n;
+      default:
+        return void 0;
+    }
+  }
+  function fmtShort(ms2) {
+    var msAbs = Math.abs(ms2);
+    if (msAbs >= d) {
+      return Math.round(ms2 / d) + "d";
+    }
+    if (msAbs >= h) {
+      return Math.round(ms2 / h) + "h";
+    }
+    if (msAbs >= m) {
+      return Math.round(ms2 / m) + "m";
+    }
+    if (msAbs >= s) {
+      return Math.round(ms2 / s) + "s";
+    }
+    return ms2 + "ms";
+  }
+  function fmtLong(ms2) {
+    var msAbs = Math.abs(ms2);
+    if (msAbs >= d) {
+      return plural(ms2, msAbs, d, "day");
+    }
+    if (msAbs >= h) {
+      return plural(ms2, msAbs, h, "hour");
+    }
+    if (msAbs >= m) {
+      return plural(ms2, msAbs, m, "minute");
+    }
+    if (msAbs >= s) {
+      return plural(ms2, msAbs, s, "second");
+    }
+    return ms2 + " ms";
+  }
+  function plural(ms2, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms2 / n) + " " + name + (isPlural ? "s" : "");
+  }
+  return ms;
+}
+export {
+  requireMs as __require
+};

package/dist/ui/packages/kit/src/constants.qwik.mjs

@@ -6,11 +6,9 @@ const QTYPE = "q:type";
 const INNER_USE_HOOK = "useCollectHooks";
 const QRL_KEY = "$qrl$";
 const COMPUTED_QRL_KEY = "$computeQrl$";
-const CHUNK_KEY = "$chunk$";
 const CAPTURE_REF_KEY = "$captureRef$";
 export {
   CAPTURE_REF_KEY,
-  CHUNK_KEY,
   COMPUTED_QRL_KEY,
   DEVTOOLS_VITE_MESSAGING_EVENT,
   INNER_USE_HOOK,

package/dist/ui/packages/kit/src/context.qwik.mjs

@@ -1,16 +1,17 @@
 import { target } from "./shared.qwik.mjs";
 import { CLIENT_RPC, CLIENT_CTX } from "./globals.qwik.mjs";
+const t = target;
 function getViteClientContext() {
-  return target[CLIENT_CTX];
+  return t[CLIENT_CTX];
 }
 function setViteClientContext(ctx) {
-  target[CLIENT_CTX] = ctx;
+  t[CLIENT_CTX] = ctx;
 }
 function getViteClientRpc() {
-  return target[CLIENT_RPC];
+  return t[CLIENT_RPC];
 }
 function setViteClientRpc(rpc) {
-  target[CLIENT_RPC] = rpc;
+  t[CLIENT_RPC] = rpc;
 }
 export {
   getViteClientContext,

package/dist/ui/utils/shiki.qwik.mjs

@@ -0,0 +1,23 @@
+import { createHighlighter } from "../node_modules/.pnpm/shiki@3.8.1/node_modules/shiki/dist/bundle-full.qwik.mjs";
+let highlighterPromise = null;
+const getHighlighter = () => {
+  if (!highlighterPromise) {
+    highlighterPromise = createHighlighter({
+      themes: [
+        "nord"
+      ],
+      langs: [
+        "json",
+        "html",
+        "tsx",
+        "js",
+        "ts",
+        "jsx"
+      ]
+    });
+  }
+  return highlighterPromise;
+};
+export {
+  getHighlighter
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwik.dev/devtools",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "license": "MIT",
   "main": "./dist/plugin/index.mjs",
   "description": "Qwik devtools package",
@@ -24,8 +24,8 @@
     "README.md"
   ],
   "peerDependencies": {
-    "@qwik.dev/core": "2.0.0-beta.11",
-    "@qwik.dev/router": "2.0.0-beta.11",
+    "@qwik.dev/core": "2.0.0-beta.15",
+    "@qwik.dev/router": "2.0.0-beta.15",
     "vite": "7.1.3",
     "@tailwindcss/postcss": "^4.1.14",
     "@tailwindcss/vite": "^4.1.14",

package/dist/ui/features/RenderTree/transfromqseq.qwik.mjs

@@ -1,91 +0,0 @@
-import { isValue } from "../../utils/type.qwik.mjs";
-let nodeIdCounter = 0;
-const objectToTree = (obj, parentPath = "") => {
-  if (!obj || typeof obj !== "object") {
-    return [];
-  }
-  const result = [];
-  if (Array.isArray(obj)) {
-    return obj.map((item, index) => {
-      return createTreeNode(item, `[${index}]`);
-    }).filter(Boolean);
-  }
-  Object.entries(obj).forEach(([key, value]) => {
-    const node = createTreeNode(value, key);
-    if (node) {
-      result.push(node);
-    }
-  });
-  return result;
-};
-function createTreeNode(value, key, path) {
-  const node = createTreeNodeObj(key);
-  if (value === null || value === void 0) {
-    node.label = `${key}: ${value}`;
-    node.elementType = "null";
-    return node;
-  }
-  if (typeof value === "boolean") {
-    node.label = `${key}: ${value}`;
-    node.elementType = "boolean";
-    return node;
-  }
-  if (typeof value === "number") {
-    node.label = `${key}: ${value}`;
-    node.elementType = "number";
-    return node;
-  }
-  if (typeof value === "string") {
-    node.label = `${key}: "${value}"`;
-    node.elementType = "string";
-    return node;
-  }
-  if (typeof value === "function") {
-    node.label = `${key}: ƒ()`;
-    node.elementType = "function";
-    if (value.name) {
-      node.label = `${key}: ƒ ${value.name}()`;
-    }
-    return node;
-  }
-  if (Array.isArray(value)) {
-    node.label = `${key}: Array[${value.length}]`;
-    node.elementType = "array";
-    node.children = value.map((item, index) => {
-      return createTreeNode(item, index.toString());
-    }).filter(Boolean);
-    return node;
-  }
-  if (typeof value === "object") {
-    if (value.constructor.name !== "Object") {
-      node.label = `${key}: Class {${value.constructor.name}}`;
-      node.elementType = "object";
-      if (isValue(value)) {
-        node.children = [
-          createTreeNode(value.value, "value")
-        ];
-      }
-    } else {
-      const keys = Object.keys(value);
-      node.label = `${key}: Object {${keys.length}}`;
-      node.elementType = "object";
-      node.children = Object.entries(value).map(([childKey, childValue]) => {
-        return createTreeNode(childValue, childKey);
-      }).filter(Boolean);
-    }
-    return node;
-  }
-  return null;
-}
-const createTreeNodeObj = (label, children = []) => {
-  return {
-    id: `node-${nodeIdCounter++}`,
-    label,
-    props: {},
-    children
-  };
-};
-export {
-  createTreeNodeObj,
-  objectToTree
-};

package/dist/ui/lib-types/ui/src/features/RenderTree/transfromqseq.d.ts

@@ -1,7 +0,0 @@
-import { TreeNode } from '../../components/Tree/Tree';
-/**
- * Convert object to TreeNode array
- * Special handling for Qwik's q:seq and other special properties
- */
-export declare const objectToTree: (obj: any, parentPath?: string) => TreeNode[];
-export declare const createTreeNodeObj: (label: string, children?: TreeNode[]) => TreeNode;