@qwik.dev/core 2.0.0-alpha.0 → 2.0.0-alpha.10

package/dist/preloader.cjs

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const build = require("@qwik.dev/core/build");
+const doc = build.isBrowser ? document : void 0;
+const config = {
+  $DEBUG$: false,
+  $maxIdlePreloads$: 25,
+  $invPreloadProbability$: 0.65
+};
+const rel = build.isBrowser && doc.createElement("link").relList.supports("modulepreload") ? "modulePreload" : "preload";
+const loadStart = Date.now();
+const BundleImportState_None = 0;
+const BundleImportState_Queued = 1;
+const BundleImportState_Preload = 2;
+const BundleImportState_Alias = 3;
+const BundleImportState_Loaded = 4;
+const bundles = /* @__PURE__ */ new Map();
+let queueDirty;
+let preloadCount = 0;
+const queue = [];
+const log = (...args) => {
+  console.log(
+    `Preloader ${Date.now() - loadStart}ms ${preloadCount}/${queue.length} queued>`,
+    ...args
+  );
+};
+const sortQueue = () => {
+  if (queueDirty) {
+    queue.sort((a, b) => a.$inverseProbability$ - b.$inverseProbability$);
+    queueDirty = false;
+  }
+};
+const trigger = () => {
+  if (!queue.length) {
+    return;
+  }
+  sortQueue();
+  while (queue.length) {
+    const bundle = queue[0];
+    const inverseProbability = bundle.$inverseProbability$;
+    const probability = 1 - inverseProbability;
+    const allowedPreloads = graph ? (
+      // The more likely the bundle, the more simultaneous preloads we want to allow
+      Math.max(1, config.$maxIdlePreloads$ * probability)
+    ) : (
+      // While the graph is not available, we limit to 2 preloads
+      2
+    );
+    if (probability === 1 || preloadCount < allowedPreloads) {
+      queue.shift();
+      preloadOne(bundle);
+    } else {
+      break;
+    }
+  }
+  if (config.$DEBUG$ && !queue.length) {
+    const loaded = [...bundles.values()].filter((b) => b.$state$ > BundleImportState_None);
+    const waitTime = loaded.reduce((acc, b) => acc + b.$waitedMs$, 0);
+    const loadTime = loaded.reduce((acc, b) => acc + b.$loadedMs$, 0);
+    log(
+      `>>>> done ${loaded.length}/${bundles.size} total: ${waitTime}ms waited, ${loadTime}ms loaded`
+    );
+  }
+};
+const preloadOne = (bundle) => {
+  if (bundle.$state$ >= BundleImportState_Preload) {
+    return;
+  }
+  preloadCount++;
+  const start = Date.now();
+  bundle.$waitedMs$ = start - bundle.$createdTs$;
+  bundle.$state$ = BundleImportState_Preload;
+  config.$DEBUG$ && log(
+    `<< load ${Math.round((1 - bundle.$inverseProbability$) * 100)}% after ${`${bundle.$waitedMs$}ms`}`,
+    bundle.$name$
+  );
+  const link = doc.createElement("link");
+  link.href = bundle.$url$;
+  link.rel = rel;
+  link.as = "script";
+  link.onload = link.onerror = () => {
+    preloadCount--;
+    const end = Date.now();
+    bundle.$loadedMs$ = end - start;
+    bundle.$state$ = BundleImportState_Loaded;
+    config.$DEBUG$ && log(`>> done after ${bundle.$loadedMs$}ms`, bundle.$name$);
+    link.remove();
+    trigger();
+  };
+  doc.head.appendChild(link);
+};
+const adjustProbabilities = (bundle, adjustFactor, seen) => {
+  if (seen == null ? void 0 : seen.has(bundle)) {
+    return;
+  }
+  const previousInverseProbability = bundle.$inverseProbability$;
+  bundle.$inverseProbability$ *= adjustFactor;
+  if (previousInverseProbability - bundle.$inverseProbability$ < 0.01) {
+    return;
+  }
+  if (bundle.$state$ < BundleImportState_Preload && bundle.$inverseProbability$ < config.$invPreloadProbability$) {
+    if (bundle.$state$ === BundleImportState_None) {
+      bundle.$state$ = BundleImportState_Queued;
+      queue.push(bundle);
+      config.$DEBUG$ && log(`queued ${Math.round((1 - bundle.$inverseProbability$) * 100)}%`, bundle.$name$);
+    }
+    queueDirty = true;
+  }
+  if (bundle.$deps$) {
+    seen || (seen = /* @__PURE__ */ new Set());
+    seen.add(bundle);
+    const probability = 1 - bundle.$inverseProbability$;
+    for (const dep of bundle.$deps$) {
+      const depBundle = getBundle(dep.$name$);
+      const prevAdjust = dep.$factor$;
+      const newInverseProbability = 1 - dep.$probability$ * probability;
+      const factor = newInverseProbability / prevAdjust;
+      dep.$factor$ = factor;
+      adjustProbabilities(depBundle, factor, seen);
+    }
+  }
+};
+const handleBundle = (name, inverseProbability) => {
+  const bundle = getBundle(name);
+  if (bundle && bundle.$inverseProbability$ > inverseProbability) {
+    adjustProbabilities(bundle, inverseProbability / bundle.$inverseProbability$);
+  }
+};
+const preload = (name, probability) => {
+  if (base == null || !name.length) {
+    return;
+  }
+  let inverseProbability = probability ? 1 - probability : 0.4;
+  if (Array.isArray(name)) {
+    for (let i = name.length - 1; i >= 0; i--) {
+      const item = name[i];
+      if (typeof item === "number") {
+        inverseProbability = 1 - item / 10;
+      } else {
+        handleBundle(item, inverseProbability);
+        inverseProbability *= 1.005;
+      }
+    }
+  } else {
+    handleBundle(name, inverseProbability);
+  }
+  if (build.isBrowser) {
+    trigger();
+  }
+};
+let base;
+let graph;
+const makeBundle = (name, deps) => {
+  const url = name.endsWith(".js") ? doc ? new URL(`${base}${name}`, doc.baseURI).toString() : name : null;
+  return {
+    $name$: name,
+    $url$: url,
+    $state$: url ? BundleImportState_None : BundleImportState_Alias,
+    $deps$: deps,
+    $inverseProbability$: 1,
+    $createdTs$: Date.now(),
+    $waitedMs$: 0,
+    $loadedMs$: 0
+  };
+};
+const parseBundleGraph = (serialized) => {
+  const graph2 = /* @__PURE__ */ new Map();
+  let i = 0;
+  while (i < serialized.length) {
+    const name = serialized[i++];
+    const deps = [];
+    let idx;
+    let probability = 1;
+    while (idx = serialized[i], typeof idx === "number") {
+      if (idx < 0) {
+        probability = -idx / 10;
+      } else {
+        deps.push({ $name$: serialized[idx], $probability$: probability, $factor$: 1 });
+      }
+      i++;
+    }
+    graph2.set(name, deps);
+  }
+  return graph2;
+};
+const getBundle = (name) => {
+  let bundle = bundles.get(name);
+  if (!bundle) {
+    let deps;
+    if (graph) {
+      deps = graph.get(name);
+      if (!deps) {
+        return;
+      }
+      if (!deps.length) {
+        deps = void 0;
+      }
+    }
+    bundle = makeBundle(name, deps);
+    bundles.set(name, bundle);
+  }
+  return bundle;
+};
+const loadBundleGraph = (basePath, serializedResponse, opts) => {
+  if (opts) {
+    if ("d" in opts) {
+      config.$DEBUG$ = !!opts.d;
+    }
+    if ("P" in opts) {
+      config.$maxIdlePreloads$ = opts["P"];
+    }
+    if ("Q" in opts) {
+      config.$invPreloadProbability$ = 1 - opts["Q"];
+    }
+  }
+  if (!build.isBrowser || basePath == null) {
+    return;
+  }
+  base = basePath;
+  if (serializedResponse) {
+    serializedResponse.then((r) => r.text()).then((text) => {
+      graph = parseBundleGraph(JSON.parse(text));
+      const toAdjust = [];
+      for (const [name, deps] of graph.entries()) {
+        const bundle = getBundle(name);
+        bundle.$deps$ = deps;
+        if (bundle.$inverseProbability$ < 1) {
+          toAdjust.push([bundle, bundle.$inverseProbability$]);
+          bundle.$inverseProbability$ = 1;
+        }
+      }
+      config.$DEBUG$ && log(`parseBundleGraph got ${graph.size} bundles, adjusting ${toAdjust.length}`);
+      for (const [bundle, inverseProbability] of toAdjust) {
+        adjustProbabilities(bundle, inverseProbability);
+      }
+      trigger();
+    }).catch(console.warn);
+  }
+};
+exports.g = parseBundleGraph;
+exports.h = handleBundle;
+exports.l = loadBundleGraph;
+exports.p = preload;

package/dist/preloader.mjs

@@ -0,0 +1,183 @@
+import { isBrowser } from "@qwik.dev/core/build";
+const doc = isBrowser ? document : void 0;
+const config = { t: 0, o: 25, l: 0.65 };
+const rel = isBrowser && doc.createElement("link").relList.supports("modulepreload") ? "modulePreload" : "preload";
+const loadStart = Date.now();
+const BundleImportState_None = 0;
+const BundleImportState_Queued = 1;
+const BundleImportState_Preload = 2;
+const BundleImportState_Alias = 3;
+const BundleImportState_Loaded = 4;
+const bundles = /* @__PURE__ */ new Map();
+let queueDirty;
+let preloadCount = 0;
+const queue = [];
+const log = (...e) => {
+  console.log(`Preloader ${Date.now() - loadStart}ms ${preloadCount}/${queue.length} queued>`, ...e);
+};
+const sortQueue = () => {
+  if (queueDirty) {
+    queue.sort((e, t) => e.u - t.u);
+    queueDirty = 0;
+  }
+};
+const trigger = () => {
+  if (!queue.length) return;
+  sortQueue();
+  while (queue.length) {
+    const e = queue[0];
+    const t = e.u;
+    const o = 1 - t;
+    const n = graph ? (
+      // The more likely the bundle, the more simultaneous preloads we want to allow
+      Math.max(1, config.o * o)
+    ) : (
+      // While the graph is not available, we limit to 2 preloads
+      2
+    );
+    if (o === 1 || preloadCount < n) {
+      queue.shift();
+      preloadOne(e);
+    } else break;
+  }
+  if (config.t && !queue.length) {
+    const e = [...bundles.values()].filter((e2) => e2.i > BundleImportState_None);
+    const t = e.reduce((e2, t2) => e2 + t2.p, 0);
+    const o = e.reduce((e2, t2) => e2 + t2.$, 0);
+    log(`>>>> done ${e.length}/${bundles.size} total: ${t}ms waited, ${o}ms loaded`);
+  }
+};
+const preloadOne = (e) => {
+  if (e.i >= BundleImportState_Preload) return;
+  preloadCount++;
+  const t = Date.now();
+  e.p = t - e.B;
+  e.i = BundleImportState_Preload;
+  config.t && log(`<< load ${Math.round((1 - e.u) * 100)}% after ${`${e.p}ms`}`, e.m);
+  const o = doc.createElement("link");
+  o.href = e.h;
+  o.rel = rel;
+  o.as = "script";
+  o.onload = o.onerror = () => {
+    preloadCount--;
+    const n = Date.now();
+    e.$ = n - t;
+    e.i = BundleImportState_Loaded;
+    config.t && log(`>> done after ${e.$}ms`, e.m);
+    o.remove();
+    trigger();
+  };
+  doc.head.appendChild(o);
+};
+const adjustProbabilities = (e, t, o) => {
+  if (o == null ? void 0 : o.has(e)) return;
+  const n = e.u;
+  e.u *= t;
+  if (n - e.u < 0.01) return;
+  if (e.i < BundleImportState_Preload && e.u < config.l) {
+    if (e.i === BundleImportState_None) {
+      e.i = BundleImportState_Queued;
+      queue.push(e);
+      config.t && log(`queued ${Math.round((1 - e.u) * 100)}%`, e.m);
+    }
+    queueDirty = 1;
+  }
+  if (e.S) {
+    o || (o = /* @__PURE__ */ new Set());
+    o.add(e);
+    const t2 = 1 - e.u;
+    for (const n2 of e.S) {
+      const e2 = getBundle(n2.m);
+      const r = n2.q;
+      const l = 1 - n2.I * t2;
+      const a = l / r;
+      n2.q = a;
+      adjustProbabilities(e2, a, o);
+    }
+  }
+};
+const handleBundle = (e, t) => {
+  const o = getBundle(e);
+  if (o && o.u > t) adjustProbabilities(o, t / o.u);
+};
+const preload = (e, t) => {
+  if (base == null || !e.length) return;
+  let o = t ? 1 - t : 0.4;
+  if (Array.isArray(e)) for (let t2 = e.length - 1; t2 >= 0; t2--) {
+    const n = e[t2];
+    if (typeof n === "number") o = 1 - n / 10;
+    else {
+      handleBundle(n, o);
+      o *= 1.005;
+    }
+  }
+  else handleBundle(e, o);
+  if (isBrowser) trigger();
+};
+let base;
+let graph;
+const makeBundle = (e, t) => {
+  const o = e.endsWith(".js") ? doc ? new URL(`${base}${e}`, doc.baseURI).toString() : e : null;
+  return { m: e, h: o, i: o ? BundleImportState_None : BundleImportState_Alias, S: t, u: 1, B: Date.now(), p: 0, $: 0 };
+};
+const parseBundleGraph = (e) => {
+  const t = /* @__PURE__ */ new Map();
+  let o = 0;
+  while (o < e.length) {
+    const n = e[o++];
+    const r = [];
+    let l;
+    let a = 1;
+    while (l = e[o], typeof l === "number") {
+      if (l < 0) a = -l / 10;
+      else r.push({ m: e[l], I: a, q: 1 });
+      o++;
+    }
+    t.set(n, r);
+  }
+  return t;
+};
+const getBundle = (e) => {
+  let t = bundles.get(e);
+  if (!t) {
+    let o;
+    if (graph) {
+      o = graph.get(e);
+      if (!o) return;
+      if (!o.length) o = void 0;
+    }
+    t = makeBundle(e, o);
+    bundles.set(e, t);
+  }
+  return t;
+};
+const loadBundleGraph = (e, t, o) => {
+  if (o) {
+    if ("d" in o) config.t = !!o.d;
+    if ("P" in o) config.o = o["P"];
+    if ("Q" in o) config.l = 1 - o["Q"];
+  }
+  if (!isBrowser || e == null) return;
+  base = e;
+  if (t) t.then((e2) => e2.text()).then((e2) => {
+    graph = parseBundleGraph(JSON.parse(e2));
+    const t2 = [];
+    for (const [e3, o2] of graph.entries()) {
+      const n = getBundle(e3);
+      n.S = o2;
+      if (n.u < 1) {
+        t2.push([n, n.u]);
+        n.u = 1;
+      }
+    }
+    config.t && log(`parseBundleGraph got ${graph.size} bundles, adjusting ${t2.length}`);
+    for (const [e3, o2] of t2) adjustProbabilities(e3, o2);
+    trigger();
+  }).catch(console.warn);
+};
+export {
+  parseBundleGraph as g,
+  handleBundle as h,
+  loadBundleGraph as l,
+  preload as p
+};