@qwik.dev/devtools 0.2.0 → 0.2.2

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

@@ -0,0 +1,116 @@
+import type { TreeNode } from '../../components/Tree/Tree';
+import type { ParsedStructure } from '@devtools/kit';
+import type { QRL } from '@qwik.dev/core';
+export declare const HOOK_CATEGORIES: {
+    readonly VARIABLE_DECLARATION: "variableDeclaration";
+    readonly EXPRESSION_STATEMENT: "expressionStatement";
+    readonly SPECIAL: "special";
+};
+export type HookCategory = (typeof HOOK_CATEGORIES)[keyof typeof HOOK_CATEGORIES];
+/**
+ * All supported hook types in the devtools
+ */
+export declare const HOOK_TYPES: readonly ["useStore", "useSignal", "useContext", "useId", "useStyles", "useStylesScoped", "useConstant", "useComputed", "useAsyncComputed", "useErrorBoundary", "useServerData", "useSerializer", "useLocation", "useNavigate", "useContent", "useDocumentHead", "useTask", "useVisibleTask", "useResource", "useContextProvider", "usePreventNavigate", "props", "listens", "render", "customhook"];
+export type HookType = (typeof HOOK_TYPES)[number];
+/**
+ * Hooks that should be hidden from the filter list by default
+ */
+export declare const HIDDEN_HOOKS: readonly HookType[];
+/**
+ * Hooks that contain QRL references (used for code lookup)
+ */
+export declare const QRL_HOOKS: readonly HookType[];
+/**
+ * QRLDev contains development metadata.
+ * Exists in @qwik.dev/core but not exported as a type.
+ *
+ * @internal Runtime type from Qwik
+ */
+export interface QRLDev {
+    file: string;
+    lo: number;
+    hi: number;
+}
+/**
+ * Internal QRL properties that exist at runtime.
+ * These are part of `QRLInternalMethods` in @qwik.dev/core but NOT exported.
+ *
+ * @see QRLInternalMethods in @qwik.dev/core/dist/core-internal.d.ts (line 2240)
+ * @internal Runtime type from Qwik
+ */
+export interface QRLInternalMethods {
+    readonly $chunk$: string | null;
+    readonly $symbol$: string;
+    readonly $hash$: string;
+    $capture$: string[] | null;
+    $captureRef$: unknown[] | null;
+}
+/**
+ * QRL with internal properties accessible.
+ * Combines public QRL type with internal runtime properties.
+ *
+ * Note: `QRLInternal<T>` exists in Qwik but is NOT exported.
+ * We define our own to access `$chunk$` and `$captureRef$`.
+ */
+export type QRLInternal<T = unknown> = QRL<T> & QRLInternalMethods;
+/**
+ * Configuration for a hook type in the store
+ */
+export interface HookConfig {
+    /** Whether this hook type is visible in the UI filter */
+    visible: boolean;
+    /** Category of the hook for special handling */
+    category: HookCategory;
+}
+/**
+ * Entry stored in the hook data store
+ */
+export interface HookEntry<T = unknown> {
+    type: HookType;
+    data: T;
+    variableName?: string;
+    category?: string;
+}
+/**
+ * Props/Listens/Render entry (simple key-value)
+ */
+export interface SimpleHookEntry {
+    data: Record<string, unknown>;
+}
+/**
+ * Parsed hook entry with full metadata
+ */
+export interface ParsedHookEntry extends ParsedStructure {
+    data: unknown;
+}
+/**
+ * Options for tree node generation
+ */
+export interface TreeNodeOptions {
+    resetIdCounter?: boolean;
+}
+/**
+ * Result of building hook tree data
+ */
+export interface HookTreeResult {
+    nodes: TreeNode[];
+    filters: HookFilterItem[];
+}
+/**
+ * Filter item for the UI
+ */
+export interface HookFilterItem {
+    key: HookType;
+    display: boolean;
+}
+export declare function isSimpleHookEntry(entry: unknown): entry is SimpleHookEntry;
+export declare function isParsedHookEntry(entry: unknown): entry is ParsedHookEntry;
+/**
+ * Type guard to check if a QRL has internal properties accessible
+ */
+export declare function isQRLInternal(qrl: unknown): qrl is QRLInternal;
+/**
+ * Safely cast QRL to QRLInternal for accessing internal properties.
+ * Use this instead of `as unknown as Record<string, unknown>`.
+ */
+export declare function asQRLInternal<T>(qrl: QRL<T>): QRLInternal<T>;

package/dist/ui/lib-types/ui/src/types/state.d.ts

@@ -1,6 +1,6 @@
 import { AssetInfo, NpmInfo, RoutesInfo, Component } from '@devtools/kit';
 import { NoSerialize, Signal } from '@qwik.dev/core';
-export type TabName = 'overview' | 'packages' | 'routes' | 'state' | 'assets' | 'components' | 'inspect' | 'renderTree';
+export type TabName = 'overview' | 'packages' | 'routes' | 'state' | 'assets' | 'components' | 'inspect' | 'renderTree' | 'codeBreack' | 'performance';
 export interface State {
     isOpen: Signal<boolean>;
     activeTab: TabName;
@@ -8,4 +8,6 @@ export interface State {
     assets: AssetInfo[];
     components: Component[];
     routes: NoSerialize<RoutesInfo[]>;
+    allDependencies: any[];
+    isLoadingDependencies: boolean;
 }

package/dist/ui/lib-types/ui/src/utils/shiki.d.ts

@@ -0,0 +1,2 @@
+import { type Highlighter } from 'shiki';
+export declare const getHighlighter: () => Promise<Highlighter>;

package/dist/ui/node_modules/.pnpm/{@qwikest_icons@0.0.13_@builder.io_qwik@1.11.0_vite@7.1.3_@types_node@20.14.11_jiti@2.4.2_tsx@4.19.2_yaml@2.7.0__ → @qwikest_icons@0.0.13_@builder.io_qwik@1.11.0_vite@7.1.3_@types_node@20.14.11_jiti@2.6._02d306fcbd9f637dd624291702bff9c0}/node_modules/@qwikest/icons/lib/hi.qwik.qwik.mjs

@@ -29,6 +29,22 @@ const HiMegaphoneMini = (props) => /* @__PURE__ */ _jsxS("svg", {
   width: "1em",
   xmlns: "http://www.w3.org/2000/svg"
 }, 0, "AV_0");
+const HiCodeBracketSolid = (props) => /* @__PURE__ */ _jsxS("svg", {
+  ...props,
+  children: /* @__PURE__ */ _jsxQ("path", null, {
+    "clip-rule": "evenodd",
+    d: "M14.447 3.027a.75.75 0 01.527.92l-4.5 16.5a.75.75 0 01-1.448-.394l4.5-16.5a.75.75 0 01.921-.526zM16.72 6.22a.75.75 0 011.06 0l5.25 5.25a.75.75 0 010 1.06l-5.25 5.25a.75.75 0 11-1.06-1.06L21.44 12l-4.72-4.72a.75.75 0 010-1.06zm-9.44 0a.75.75 0 010 1.06L2.56 12l4.72 4.72a.75.75 0 11-1.06 1.06L.97 12.53a.75.75 0 010-1.06l5.25-5.25a.75.75 0 011.06 0z",
+    "fill-rule": "evenodd"
+  }, null, 3, null)
+}, {
+  "aria-hidden": "true",
+  "data-qwikest-icon": true,
+  fill: "currentColor",
+  height: "1em",
+  viewBox: "0 0 24 24",
+  width: "1em",
+  xmlns: "http://www.w3.org/2000/svg"
+}, 0, "C8_0");
 const HiBoltOutline = (props) => /* @__PURE__ */ _jsxS("svg", {
   ...props,
   children: /* @__PURE__ */ _jsxQ("path", null, {
@@ -47,6 +63,24 @@ const HiBoltOutline = (props) => /* @__PURE__ */ _jsxS("svg", {
   width: "1em",
   xmlns: "http://www.w3.org/2000/svg"
 }, 0, "z0_0");
+const HiClockOutline = (props) => /* @__PURE__ */ _jsxS("svg", {
+  ...props,
+  children: /* @__PURE__ */ _jsxQ("path", null, {
+    d: "M12 6v6h4.5m4.5 0a9 9 0 11-18 0 9 9 0 0118 0z",
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round"
+  }, null, 3, null)
+}, {
+  "aria-hidden": "true",
+  "data-qwikest-icon": true,
+  fill: "none",
+  height: "1em",
+  stroke: "currentColor",
+  "stroke-width": "1.5",
+  viewBox: "0 0 24 24",
+  width: "1em",
+  xmlns: "http://www.w3.org/2000/svg"
+}, 0, "l1_0");
 const HiCubeOutline = (props) => /* @__PURE__ */ _jsxS("svg", {
   ...props,
   children: /* @__PURE__ */ _jsxQ("path", null, {
@@ -122,6 +156,8 @@ const HiSunOutline = (props) => /* @__PURE__ */ _jsxS("svg", {
 export {
   HiBoltOutline,
   HiChevronUpMini,
+  HiClockOutline,
+  HiCodeBracketSolid,
   HiCubeOutline,
   HiMegaphoneMini,
   HiMoonOutline,

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

@@ -0,0 +1,177 @@
+import { __module as browser } from "../../../../../../_virtual/browser.qwik2.mjs";
+import { __require as requireCommon } from "./common.qwik.mjs";
+var hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser) return browser.exports;
+  hasRequiredBrowser = 1;
+  (function(module, exports) {
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      let m;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module.exports = requireCommon()(exports);
+    const { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  })(browser, browser.exports);
+  return browser.exports;
+}
+export {
+  requireBrowser as __require
+};

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,