@qwik.dev/devtools 0.0.3 → 0.0.5

package/dist/component/node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/transformer.qwik.mjs

@@ -0,0 +1,203 @@
+import { isUndefined, isBigint, isDate, isError, isRegExp, isSet, isMap, isNaNValue, isInfinite, isURL, isArray, isSymbol, isTypedArray } from "./is.qwik.mjs";
+import { findArr } from "./util.qwik.mjs";
+function simpleTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+const simpleRules = [
+  simpleTransformation(isUndefined, "undefined", () => null, () => void 0),
+  simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
+    if (typeof BigInt !== "undefined") {
+      return BigInt(v);
+    }
+    console.error("Please add a BigInt polyfill.");
+    return v;
+  }),
+  simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
+  simpleTransformation(isError, "Error", (v, superJson) => {
+    const baseError = {
+      name: v.name,
+      message: v.message
+    };
+    superJson.allowedErrorProps.forEach((prop) => {
+      baseError[prop] = v[prop];
+    });
+    return baseError;
+  }, (v, superJson) => {
+    const e = new Error(v.message);
+    e.name = v.name;
+    e.stack = v.stack;
+    superJson.allowedErrorProps.forEach((prop) => {
+      e[prop] = v[prop];
+    });
+    return e;
+  }),
+  simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
+    const body = regex.slice(1, regex.lastIndexOf("/"));
+    const flags = regex.slice(regex.lastIndexOf("/") + 1);
+    return new RegExp(body, flags);
+  }),
+  simpleTransformation(
+    isSet,
+    "set",
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    (v) => [...v.values()],
+    (v) => new Set(v)
+  ),
+  simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
+  simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
+    if (isNaNValue(v)) {
+      return "NaN";
+    }
+    if (v > 0) {
+      return "Infinity";
+    } else {
+      return "-Infinity";
+    }
+  }, Number),
+  simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
+    return "-0";
+  }, Number),
+  simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
+];
+function compositeTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+const symbolRule = compositeTransformation((s, superJson) => {
+  if (isSymbol(s)) {
+    const isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
+    return isRegistered;
+  }
+  return false;
+}, (s, superJson) => {
+  const identifier = superJson.symbolRegistry.getIdentifier(s);
+  return ["symbol", identifier];
+}, (v) => v.description, (_, a, superJson) => {
+  const value = superJson.symbolRegistry.getValue(a[1]);
+  if (!value) {
+    throw new Error("Trying to deserialize unknown symbol");
+  }
+  return value;
+});
+const constructorToName = [
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  Uint8ClampedArray
+].reduce((obj, ctor) => {
+  obj[ctor.name] = ctor;
+  return obj;
+}, {});
+const typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a) => {
+  const ctor = constructorToName[a[1]];
+  if (!ctor) {
+    throw new Error("Trying to deserialize unknown typed array");
+  }
+  return new ctor(v);
+});
+function isInstanceOfRegisteredClass(potentialClass, superJson) {
+  if (potentialClass?.constructor) {
+    const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+    return isRegistered;
+  }
+  return false;
+}
+const classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
+  const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
+  return ["class", identifier];
+}, (clazz, superJson) => {
+  const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+  if (!allowedProps) {
+    return { ...clazz };
+  }
+  const result = {};
+  allowedProps.forEach((prop) => {
+    result[prop] = clazz[prop];
+  });
+  return result;
+}, (v, a, superJson) => {
+  const clazz = superJson.classRegistry.getValue(a[1]);
+  if (!clazz) {
+    throw new Error(`Trying to deserialize unknown class '${a[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+  }
+  return Object.assign(Object.create(clazz.prototype), v);
+});
+const customRule = compositeTransformation((value, superJson) => {
+  return !!superJson.customTransformerRegistry.findApplicable(value);
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return ["custom", transformer.name];
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return transformer.serialize(value);
+}, (v, a, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findByName(a[1]);
+  if (!transformer) {
+    throw new Error("Trying to deserialize unknown custom value");
+  }
+  return transformer.deserialize(v);
+});
+const compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
+const transformValue = (value, superJson) => {
+  const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableCompositeRule) {
+    return {
+      value: applicableCompositeRule.transform(value, superJson),
+      type: applicableCompositeRule.annotation(value, superJson)
+    };
+  }
+  const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableSimpleRule) {
+    return {
+      value: applicableSimpleRule.transform(value, superJson),
+      type: applicableSimpleRule.annotation
+    };
+  }
+  return void 0;
+};
+const simpleRulesByAnnotation = {};
+simpleRules.forEach((rule) => {
+  simpleRulesByAnnotation[rule.annotation] = rule;
+});
+const untransformValue = (json, type, superJson) => {
+  if (isArray(type)) {
+    switch (type[0]) {
+      case "symbol":
+        return symbolRule.untransform(json, type, superJson);
+      case "class":
+        return classRule.untransform(json, type, superJson);
+      case "custom":
+        return customRule.untransform(json, type, superJson);
+      case "typed-array":
+        return typedArrayRule.untransform(json, type, superJson);
+      default:
+        throw new Error("Unknown transformation: " + type);
+    }
+  } else {
+    const transformation = simpleRulesByAnnotation[type];
+    if (!transformation) {
+      throw new Error("Unknown transformation: " + type);
+    }
+    return transformation.untransform(json, superJson);
+  }
+};
+export {
+  isInstanceOfRegisteredClass,
+  transformValue,
+  untransformValue
+};

package/dist/component/node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/util.qwik.cjs

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function valuesOfObj(record) {
+  if ("values" in Object) {
+    return Object.values(record);
+  }
+  const values = [];
+  for (const key in record) {
+    if (record.hasOwnProperty(key)) {
+      values.push(record[key]);
+    }
+  }
+  return values;
+}
+function find(record, predicate) {
+  const values = valuesOfObj(record);
+  if ("find" in values) {
+    return values.find(predicate);
+  }
+  const valuesNotNever = values;
+  for (let i = 0; i < valuesNotNever.length; i++) {
+    const value = valuesNotNever[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function forEach(record, run) {
+  Object.entries(record).forEach(([key, value]) => run(value, key));
+}
+function includes(arr, value) {
+  return arr.indexOf(value) !== -1;
+}
+function findArr(record, predicate) {
+  for (let i = 0; i < record.length; i++) {
+    const value = record[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+exports.find = find;
+exports.findArr = findArr;
+exports.forEach = forEach;
+exports.includes = includes;

package/dist/component/node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/util.qwik.mjs

@@ -0,0 +1,47 @@
+function valuesOfObj(record) {
+  if ("values" in Object) {
+    return Object.values(record);
+  }
+  const values = [];
+  for (const key in record) {
+    if (record.hasOwnProperty(key)) {
+      values.push(record[key]);
+    }
+  }
+  return values;
+}
+function find(record, predicate) {
+  const values = valuesOfObj(record);
+  if ("find" in values) {
+    return values.find(predicate);
+  }
+  const valuesNotNever = values;
+  for (let i = 0; i < valuesNotNever.length; i++) {
+    const value = valuesNotNever[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function forEach(record, run) {
+  Object.entries(record).forEach(([key, value]) => run(value, key));
+}
+function includes(arr, value) {
+  return arr.indexOf(value) !== -1;
+}
+function findArr(record, predicate) {
+  for (let i = 0; i < record.length; i++) {
+    const value = record[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+export {
+  find,
+  findArr,
+  forEach,
+  includes
+};

package/dist/component/node_modules/.pnpm/vite-hot-client@0.2.4_vite@5.4.10_@types_node@20.14.11_/node_modules/vite-hot-client/dist/index.qwik.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+async function getViteClient(base = "/", warning = true) {
+  try {
+    const url = `${base}@vite/client`;
+    const res = await fetch(url);
+    const text = await res.text();
+    if (text.startsWith("<") || !res.headers.get("content-type")?.includes("javascript"))
+      throw new Error("Not javascript");
+    return await import(
+      /* @vite-ignore */
+      url
+    );
+  } catch {
+    if (warning)
+      console.error(`[vite-hot-client] Failed to import "${base}@vite/client"`);
+  }
+  return void 0;
+}
+function guessBasesFromPathname(pathname = window.location.pathname) {
+  return pathname.split("/").map((i, idx, arr) => arr.slice(0, idx + 1).join("/") || "/");
+}
+async function tryCreateHotContext(path = "/___", bases) {
+  bases = bases ?? guessBasesFromPathname();
+  for (const base of bases) {
+    const viteClient = await getViteClient(base, false);
+    const hot = viteClient?.createHotContext(path);
+    if (hot)
+      return hot;
+  }
+  console.error("[vite-hot-client] Failed to import vite client, tried with:", bases);
+}
+exports.getViteClient = getViteClient;
+exports.guessBasesFromPathname = guessBasesFromPathname;
+exports.tryCreateHotContext = tryCreateHotContext;

package/dist/component/node_modules/.pnpm/vite-hot-client@0.2.4_vite@5.4.10_@types_node@20.14.11_/node_modules/vite-hot-client/dist/index.qwik.mjs

@@ -0,0 +1,35 @@
+async function getViteClient(base = "/", warning = true) {
+  try {
+    const url = `${base}@vite/client`;
+    const res = await fetch(url);
+    const text = await res.text();
+    if (text.startsWith("<") || !res.headers.get("content-type")?.includes("javascript"))
+      throw new Error("Not javascript");
+    return await import(
+      /* @vite-ignore */
+      url
+    );
+  } catch {
+    if (warning)
+      console.error(`[vite-hot-client] Failed to import "${base}@vite/client"`);
+  }
+  return void 0;
+}
+function guessBasesFromPathname(pathname = window.location.pathname) {
+  return pathname.split("/").map((i, idx, arr) => arr.slice(0, idx + 1).join("/") || "/");
+}
+async function tryCreateHotContext(path = "/___", bases) {
+  bases = bases ?? guessBasesFromPathname();
+  for (const base of bases) {
+    const viteClient = await getViteClient(base, false);
+    const hot = viteClient?.createHotContext(path);
+    if (hot)
+      return hot;
+  }
+  console.error("[vite-hot-client] Failed to import vite client, tried with:", bases);
+}
+export {
+  getViteClient,
+  guessBasesFromPathname,
+  tryCreateHotContext
+};

package/{lib/kit → dist/component/packages/kit/src}/client.qwik.cjs

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const SuperJSON = require("superjson");
-const birpc = require("birpc");
+const index$1 = require("../../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/index.qwik.cjs");
+const index = require("../../../node_modules/.pnpm/birpc@0.2.19/node_modules/birpc/dist/index.qwik.cjs");
 const constants = require("./constants.qwik.cjs");
 const context = require("./context.qwik.cjs");
 function createClientRpc(functions) {
   const client = context.getViteClientContext();
-  const rpc = birpc.createBirpc(functions, {
-    post: (data) => client.send(constants.DEVTOOLS_VITE_MESSAGING_EVENT, SuperJSON.stringify(data)),
+  const rpc = index.createBirpc(functions, {
+    post: (data) => client.send(constants.DEVTOOLS_VITE_MESSAGING_EVENT, index$1.default.stringify(data)),
     on: (fn) => client.on(constants.DEVTOOLS_VITE_MESSAGING_EVENT, (data) => {
-      fn(SuperJSON.parse(data));
+      fn(index$1.default.parse(data));
     }),
     timeout: 12e4
   });

package/{lib/kit → dist/component/packages/kit/src}/client.qwik.mjs

@@ -1,5 +1,5 @@
-import SuperJSON from "superjson";
-import { createBirpc } from "birpc";
+import SuperJSON from "../../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/index.qwik.mjs";
+import { createBirpc } from "../../../node_modules/.pnpm/birpc@0.2.19/node_modules/birpc/dist/index.qwik.mjs";
 import { DEVTOOLS_VITE_MESSAGING_EVENT } from "./constants.qwik.mjs";
 import { setViteClientRpc, getViteClientContext } from "./context.qwik.mjs";
 function createClientRpc(functions) {

package/{lib/kit → dist/component/packages/kit/src}/context.qwik.cjs

@@ -8,15 +8,6 @@ function getViteClientContext() {
 function setViteClientContext(ctx) {
   shared.target[globals.CLIENT_CTX] = ctx;
 }
-function getViteServerContext() {
-  return shared.target[globals.SERVER_CTX];
-}
-function setViteServerContext(ctx) {
-  shared.target[globals.SERVER_CTX] = ctx;
-}
-function setViteServerRpc(rpc) {
-  shared.target[globals.SERVER_RPC] = rpc;
-}
 function getViteClientRpc() {
   return shared.target[globals.CLIENT_RPC];
 }
@@ -25,8 +16,5 @@ function setViteClientRpc(rpc) {
 }
 exports.getViteClientContext = getViteClientContext;
 exports.getViteClientRpc = getViteClientRpc;
-exports.getViteServerContext = getViteServerContext;
 exports.setViteClientContext = setViteClientContext;
 exports.setViteClientRpc = setViteClientRpc;
-exports.setViteServerContext = setViteServerContext;
-exports.setViteServerRpc = setViteServerRpc;

package/{lib/kit → dist/component/packages/kit/src}/context.qwik.mjs

@@ -1,20 +1,11 @@
 import { target } from "./shared.qwik.mjs";
-import { CLIENT_CTX, SERVER_CTX, CLIENT_RPC, SERVER_RPC } from "./globals.qwik.mjs";
+import { CLIENT_CTX, CLIENT_RPC } from "./globals.qwik.mjs";
 function getViteClientContext() {
   return target[CLIENT_CTX];
 }
 function setViteClientContext(ctx) {
   target[CLIENT_CTX] = ctx;
 }
-function getViteServerContext() {
-  return target[SERVER_CTX];
-}
-function setViteServerContext(ctx) {
-  target[SERVER_CTX] = ctx;
-}
-function setViteServerRpc(rpc) {
-  target[SERVER_RPC] = rpc;
-}
 function getViteClientRpc() {
   return target[CLIENT_RPC];
 }
@@ -24,9 +15,6 @@ function setViteClientRpc(rpc) {
 export {
   getViteClientContext,
   getViteClientRpc,
-  getViteServerContext,
   setViteClientContext,
-  setViteClientRpc,
-  setViteServerContext,
-  setViteServerRpc
+  setViteClientRpc
 };

package/{lib/kit → dist/component/packages/kit/src}/globals.qwik.cjs

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const CLIENT_CTX = "__qwik_client_ctx__";
-const SERVER_CTX = "__qwik_server_ctx__";
-const SERVER_RPC = "__qwik_server_rpc__";
 const CLIENT_RPC = "__qwik_client_rpc__";
 exports.CLIENT_CTX = CLIENT_CTX;
 exports.CLIENT_RPC = CLIENT_RPC;
-exports.SERVER_CTX = SERVER_CTX;
-exports.SERVER_RPC = SERVER_RPC;

package/dist/component/packages/kit/src/globals.qwik.mjs

@@ -0,0 +1,6 @@
+const CLIENT_CTX = "__qwik_client_ctx__";
+const CLIENT_RPC = "__qwik_client_rpc__";
+export {
+  CLIENT_CTX,
+  CLIENT_RPC
+};