@qwik.dev/core 2.0.0-alpha.8 → 2.0.0-beta.1

package/dist/preloader.cjs

@@ -0,0 +1,269 @@
+"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 isJSRegex = /\.[mc]?js$/;
+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 >= 0.99 || 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 = new URL(`${base}${bundle.$name$}`, doc.baseURI).toString();
+  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, newInverseProbability, seen) => {
+  if (seen == null ? void 0 : seen.has(bundle)) {
+    return;
+  }
+  const previousInverseProbability = bundle.$inverseProbability$;
+  bundle.$inverseProbability$ = newInverseProbability;
+  if (previousInverseProbability - bundle.$inverseProbability$ < 0.01) {
+    return;
+  }
+  if (
+    // don't queue until we have initialized the preloader
+    base != null && 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$);
+      if (depBundle.$inverseProbability$ === 0) {
+        continue;
+      }
+      let newInverseProbability2;
+      if (dep.$importProbability$ > 0.5 && (probability === 1 || probability >= 0.99 && depsCount < 100)) {
+        depsCount++;
+        newInverseProbability2 = Math.min(0.01, 1 - dep.$importProbability$);
+      } else {
+        const newInverseImportProbability = 1 - dep.$importProbability$ * probability;
+        const prevAdjust = dep.$factor$;
+        const factor = newInverseImportProbability / prevAdjust;
+        newInverseProbability2 = Math.max(0.02, depBundle.$inverseProbability$ * factor);
+        dep.$factor$ = factor;
+      }
+      adjustProbabilities(depBundle, newInverseProbability2, seen);
+    }
+  }
+};
+const handleBundle = (name, inverseProbability) => {
+  const bundle = getBundle(name);
+  if (bundle && bundle.$inverseProbability$ > inverseProbability) {
+    adjustProbabilities(bundle, inverseProbability);
+  }
+};
+let depsCount;
+const preload = (name, probability) => {
+  if (!(name == null ? void 0 : name.length)) {
+    return;
+  }
+  depsCount = 0;
+  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);
+      }
+    }
+  } else {
+    handleBundle(name, inverseProbability);
+  }
+  if (build.isBrowser) {
+    trigger();
+  }
+};
+if (build.isBrowser) {
+  document.addEventListener("qsymbol", (ev) => {
+    const { symbol, href } = ev.detail;
+    if (href) {
+      const hash = symbol.slice(symbol.lastIndexOf("_") + 1);
+      preload(hash, 1);
+    }
+  });
+}
+let base;
+let graph;
+const makeBundle = (name, deps) => {
+  return {
+    $name$: name,
+    $state$: isJSRegex.test(name) ? 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],
+          $importProbability$: 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,198 @@
+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 isJSRegex = /\.[mc]?js$/;
+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 >= 0.99 || 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 = new URL(`${base}${e.m}`, doc.baseURI).toString();
+  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 (
+    // don't queue until we have initialized the preloader
+    base != null && 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.h) {
+    o || (o = /* @__PURE__ */ new Set());
+    o.add(e);
+    const t2 = 1 - e.u;
+    for (const n2 of e.h) {
+      const e2 = getBundle(n2.m);
+      if (e2.u === 0) continue;
+      let r;
+      if (n2.S > 0.5 && (t2 === 1 || t2 >= 0.99 && depsCount < 100)) {
+        depsCount++;
+        r = Math.min(0.01, 1 - n2.S);
+      } else {
+        const o2 = 1 - n2.S * t2;
+        const s = n2.q;
+        const l = o2 / s;
+        r = Math.max(0.02, e2.u * l);
+        n2.q = l;
+      }
+      adjustProbabilities(e2, r, o);
+    }
+  }
+};
+const handleBundle = (e, t) => {
+  const o = getBundle(e);
+  if (o && o.u > t) adjustProbabilities(o, t);
+};
+let depsCount;
+const preload = (e, t) => {
+  if (!(e == null ? void 0 : e.length)) return;
+  depsCount = 0;
+  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);
+  }
+  else handleBundle(e, o);
+  if (isBrowser) trigger();
+};
+if (isBrowser) document.addEventListener("qsymbol", (e) => {
+  const { symbol: t, href: o } = e.detail;
+  if (o) {
+    const e2 = t.slice(t.lastIndexOf("_") + 1);
+    preload(e2, 1);
+  }
+});
+let base;
+let graph;
+const makeBundle = (e, t) => ({ m: e, i: isJSRegex.test(e) ? BundleImportState_None : BundleImportState_Alias, h: 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 s;
+    let l = 1;
+    while (s = e[o], typeof s === "number") {
+      if (s < 0) l = -s / 10;
+      else r.push({ m: e[s], S: l, 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.h = 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
+};