@manyducks.co/dolla 0.69.3 → 0.69.4

package/lib/classes/EventEmitter.d.ts

@@ -0,0 +1,44 @@
+type EventListeners<E extends EventMap> = {
+    [K in keyof E]?: EventCallback<E, K>[];
+};
+export type EventCallback<E extends EventMap, K extends keyof E> = (event: EmittedEvent<E, K>) => void;
+/**
+ * A map of event names and data values that their listener callbacks take.
+ */
+export interface EventMap {
+    [name: string]: any;
+}
+/**
+ * A hub for subscribing to and emitting events. A good pattern when you want to notify several parts of your app
+ * at once when a condition changes in a central location. This is a similar pattern to Readable and Writable as far as
+ * observability goes, but with the added ability to emit multiple event types each with their own separate listeners.
+ */
+export declare class EventEmitter<E extends EventMap = EventMap> {
+    listeners: EventListeners<E>;
+    /**
+     * Emit an event.
+     */
+    emit<K extends keyof E>(name: K, data: E[K]): void;
+    /**
+     * Listen for an event. The callback will be called whenever that event is emitted.
+     * Returns a function that will cancel this listener when called.
+     */
+    on<K extends keyof EventListeners<E>>(name: K, callback: EventCallback<E, K>): () => void;
+    /**
+     * Listen for the next emitted event. The callback will be called once the next time that event is emitted,
+     * and then never again. Returns a function that will cancel this listener when called.
+     */
+    once<K extends keyof EventListeners<E>>(name: K, callback: EventCallback<E, K>): () => void;
+    /**
+     * Cancel a listener by passing the callback that was originally used to register it.
+     */
+    off<K extends keyof EventListeners<E>>(name: K, callback: EventCallback<E, K>): void;
+}
+declare class EmittedEvent<E extends EventMap, K extends keyof E> {
+    /**
+     * Data object emitted with this event.
+     */
+    data: E[K];
+    constructor(data: E[K]);
+}
+export {};

package/lib/index.js

@@ -29,7 +29,7 @@ var require_lib = __commonJS({
   "node_modules/simple-color-hash/lib/index.js"(exports, module) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    var _slicedToArray = function() {
+    var _slicedToArray = /* @__PURE__ */ function() {
       function a(a2, b) {
         var c = [], d = true, e = false, f = void 0;
         try {
@@ -88,7 +88,55 @@ var require_lib = __commonJS({
   }
 });
 
-// node_modules/@borf/bedrock/lib/typeChecking.js
+// src/classes/CrashCollector.ts
+var CrashCollector = class {
+  #errors = [];
+  #errorCallbacks = [];
+  /**
+   * Registers a callback to receive all errors that pass through the CrashCollector.
+   * Returns a function that cancels this listener when called.
+   */
+  onError(callback) {
+    this.#errorCallbacks.push(callback);
+    return () => {
+      this.#errorCallbacks.splice(this.#errorCallbacks.indexOf(callback), 1);
+    };
+  }
+  /**
+   * Reports an unrecoverable error that requires crashing the whole app.
+   */
+  crash({ error, componentName }) {
+    const ctx = {
+      error,
+      severity: "crash",
+      componentName: componentName ?? "anonymous component"
+    };
+    this.#errors.push(ctx);
+    for (const callback of this.#errorCallbacks) {
+      callback(ctx);
+    }
+    throw error;
+  }
+  /**
+   * Reports a recoverable error.
+   */
+  error({ error, componentName }) {
+    const ctx = {
+      error,
+      severity: "error",
+      componentName: componentName ?? "anonymous component"
+    };
+    this.#errors.push(ctx);
+    for (const callback of this.#errorCallbacks) {
+      callback(ctx);
+    }
+  }
+};
+
+// src/classes/DebugHub.ts
+var import_simple_color_hash = __toESM(require_lib(), 1);
+
+// src/typeChecking.ts
 function typeOf(value) {
   if (value === void 0) {
     return "undefined";
@@ -209,274 +257,7 @@ function formatError(value, message) {
   return message.replaceAll("%t", typeName).replaceAll("%v", valueString);
 }
 
-// node_modules/@borf/bedrock/lib/routing.js
-var FragTypes;
-(function(FragTypes2) {
-  FragTypes2[FragTypes2["Literal"] = 1] = "Literal";
-  FragTypes2[FragTypes2["Param"] = 2] = "Param";
-  FragTypes2[FragTypes2["Wildcard"] = 3] = "Wildcard";
-  FragTypes2[FragTypes2["NumericParam"] = 4] = "NumericParam";
-})(FragTypes || (FragTypes = {}));
-function splitPath(path) {
-  assertString(path, "Expected `path` to be a string. Got type: %t, value: %v");
-  return path.split("/").map((f) => f.trim()).filter((f) => f !== "");
-}
-function joinPath(parts) {
-  assertArrayOf((part) => isFunction(part?.toString), parts, "Expected `parts` to be an array of objects with a .toString() method. Got type: %t, value: %v");
-  parts = parts.filter((x) => x).flatMap(String);
-  let joined = parts.shift()?.toString();
-  if (joined) {
-    for (const part of parts.map((p) => p.toString())) {
-      if (part.startsWith(".")) {
-        joined = resolvePath(joined, part);
-      } else if (joined[joined.length - 1] !== "/") {
-        if (part[0] !== "/") {
-          joined += "/" + part;
-        } else {
-          joined += part;
-        }
-      } else {
-        if (part[0] === "/") {
-          joined += part.slice(1);
-        } else {
-          joined += part;
-        }
-      }
-    }
-    if (joined && joined !== "/" && joined.endsWith("/")) {
-      joined = joined.slice(0, joined.length - 1);
-    }
-  }
-  return joined ?? "";
-}
-function resolvePath(base, part) {
-  assertString(base, "Expected `base` to be a string. Got type: %t, value: %v");
-  if (part == null) {
-    part = base;
-    base = "";
-  }
-  if (part.startsWith("/")) {
-    return part;
-  }
-  let resolved = base;
-  while (true) {
-    if (part.startsWith("..")) {
-      for (let i = resolved.length; i > 0; --i) {
-        if (resolved[i] === "/" || i === 0) {
-          resolved = resolved.slice(0, i);
-          part = part.replace(/^\.\.\/?/, "");
-          break;
-        }
-      }
-    } else if (part.startsWith(".")) {
-      part = part.replace(/^\.\/?/, "");
-    } else {
-      break;
-    }
-  }
-  return joinPath([resolved, part]);
-}
-function parseQueryParams(query) {
-  if (!query)
-    return {};
-  const entries = query.split("&").filter((x) => x.trim() !== "").map((entry) => {
-    const [key, value] = entry.split("=").map((x) => x.trim());
-    if (value.toLowerCase() === "true") {
-      return [key, true];
-    }
-    if (value.toLowerCase() === "false") {
-      return [key, false];
-    }
-    if (!isNaN(Number(value))) {
-      return [key, Number(value)];
-    }
-    return [key, value];
-  });
-  return Object.fromEntries(entries);
-}
-function matchRoutes(routes, url, options = {}) {
-  const [path, query] = url.split("?");
-  const parts = splitPath(path);
-  routes:
-    for (const route of routes) {
-      const { fragments } = route;
-      const hasWildcard = fragments[fragments.length - 1]?.type === FragTypes.Wildcard;
-      if (!hasWildcard && fragments.length !== parts.length) {
-        continue routes;
-      }
-      if (options.willMatch && !options.willMatch(route)) {
-        continue routes;
-      }
-      const matched = [];
-      fragments:
-        for (let i = 0; i < fragments.length; i++) {
-          const part = parts[i];
-          const frag = fragments[i];
-          if (part == null && frag.type !== FragTypes.Wildcard) {
-            continue routes;
-          }
-          switch (frag.type) {
-            case FragTypes.Literal:
-              if (frag.name.toLowerCase() === part.toLowerCase()) {
-                matched.push(frag);
-                break;
-              } else {
-                continue routes;
-              }
-            case FragTypes.Param:
-              matched.push({ ...frag, value: part });
-              break;
-            case FragTypes.Wildcard:
-              matched.push({ ...frag, value: parts.slice(i).join("/") });
-              break fragments;
-            case FragTypes.NumericParam:
-              if (!isNaN(Number(part))) {
-                matched.push({ ...frag, value: Number(part) });
-                break;
-              } else {
-                continue routes;
-              }
-            default:
-              throw new Error(`Unknown fragment type: ${frag.type}`);
-          }
-        }
-      const params = /* @__PURE__ */ Object.create(null);
-      for (const frag of matched) {
-        if (frag.type === FragTypes.Param) {
-          params[frag.name] = decodeURIComponent(frag.value);
-        }
-        if (frag.type === FragTypes.NumericParam) {
-          params[frag.name] = frag.value;
-        }
-        if (frag.type === FragTypes.Wildcard) {
-          params.wildcard = "/" + decodeURIComponent(frag.value);
-        }
-      }
-      return {
-        path: "/" + matched.map((f) => f.value).join("/"),
-        pattern: "/" + fragments.map((f) => {
-          if (f.type === FragTypes.Param) {
-            return `{${f.name}}`;
-          }
-          if (f.type === FragTypes.NumericParam) {
-            return `{#${f.name}}`;
-          }
-          return f.name;
-        }).join("/"),
-        params,
-        query: parseQueryParams(query),
-        meta: route.meta
-      };
-    }
-}
-function sortRoutes(routes) {
-  const withoutParams = [];
-  const withNumericParams = [];
-  const withParams = [];
-  const wildcard = [];
-  for (const route of routes) {
-    const { fragments } = route;
-    if (fragments.some((f) => f.type === FragTypes.Wildcard)) {
-      wildcard.push(route);
-    } else if (fragments.some((f) => f.type === FragTypes.NumericParam)) {
-      withNumericParams.push(route);
-    } else if (fragments.some((f) => f.type === FragTypes.Param)) {
-      withParams.push(route);
-    } else {
-      withoutParams.push(route);
-    }
-  }
-  const bySizeDesc = (a, b) => {
-    if (a.fragments.length > b.fragments.length) {
-      return -1;
-    } else {
-      return 1;
-    }
-  };
-  withoutParams.sort(bySizeDesc);
-  withNumericParams.sort(bySizeDesc);
-  withParams.sort(bySizeDesc);
-  wildcard.sort(bySizeDesc);
-  return [...withoutParams, ...withNumericParams, ...withParams, ...wildcard];
-}
-function patternToFragments(pattern) {
-  const parts = splitPath(pattern);
-  const fragments = [];
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (part === "*") {
-      if (i !== parts.length - 1) {
-        throw new Error(`Wildcard must be at the end of a pattern. Received: ${pattern}`);
-      }
-      fragments.push({
-        type: FragTypes.Wildcard,
-        name: "*",
-        value: null
-      });
-    } else if (part.at(0) === "{" && part.at(-1) === "}") {
-      fragments.push({
-        type: part[1] === "#" ? FragTypes.NumericParam : FragTypes.Param,
-        name: part[1] === "#" ? part.slice(2, -1) : part.slice(1, -1),
-        value: null
-      });
-    } else {
-      fragments.push({
-        type: FragTypes.Literal,
-        name: part,
-        value: part
-      });
-    }
-  }
-  return fragments;
-}
-
-// src/classes/CrashCollector.ts
-var CrashCollector = class {
-  #errors = [];
-  #errorCallbacks = [];
-  /**
-   * Registers a callback to receive all errors that pass through the CrashCollector.
-   * Returns a function that cancels this listener when called.
-   */
-  onError(callback) {
-    this.#errorCallbacks.push(callback);
-    return () => {
-      this.#errorCallbacks.splice(this.#errorCallbacks.indexOf(callback), 1);
-    };
-  }
-  /**
-   * Reports an unrecoverable error that requires crashing the whole app.
-   */
-  crash({ error, componentName }) {
-    const ctx = {
-      error,
-      severity: "crash",
-      componentName: componentName ?? "anonymous component"
-    };
-    this.#errors.push(ctx);
-    for (const callback of this.#errorCallbacks) {
-      callback(ctx);
-    }
-    throw error;
-  }
-  /**
-   * Reports a recoverable error.
-   */
-  error({ error, componentName }) {
-    const ctx = {
-      error,
-      severity: "error",
-      componentName: componentName ?? "anonymous component"
-    };
-    this.#errors.push(ctx);
-    for (const callback of this.#errorCallbacks) {
-      callback(ctx);
-    }
-  }
-};
-
 // src/classes/DebugHub.ts
-var import_simple_color_hash = __toESM(require_lib(), 1);
 var DebugHub = class {
   #filter = "*,-dolla/*";
   #matcher;
@@ -686,7 +467,9 @@ function $$(initialValue, config) {
 }
 function $(...args) {
   if (args.length > 1) {
-    return computed(...args);
+    const callback = args.pop();
+    const readables = args.flat().map(readable);
+    return computed(...readables, callback);
   } else {
     return readable(args[0]);
   }
@@ -715,7 +498,6 @@ function computed(...args) {
   if (typeof compute !== "function") {
     throw new TypeError(`Final argument must be a function. Got ${typeOf(compute)}: ${compute}`);
   }
-  args = args.flat().map(readable);
   if (args.length < 1) {
     throw new Error(`Must pass at least one value before the callback function.`);
   }
@@ -881,7 +663,7 @@ function proxy(source, config) {
 }
 function observe(...args) {
   const callback = args.pop();
-  const readables = args.flat();
+  const readables = args.flat().map(readable);
   if (readables.length === 0) {
     throw new TypeError(`Expected at least one readable.`);
   }
@@ -3146,6 +2928,226 @@ function parsePath(path) {
   return parsedPath;
 }
 
+// src/routing.ts
+function splitPath(path) {
+  assertString(path, "Expected `path` to be a string. Got type: %t, value: %v");
+  return path.split("/").map((f) => f.trim()).filter((f) => f !== "");
+}
+function joinPath(parts) {
+  assertArrayOf(
+    (part) => isFunction(part?.toString),
+    parts,
+    "Expected `parts` to be an array of objects with a .toString() method. Got type: %t, value: %v"
+  );
+  parts = parts.filter((x) => x).flatMap(String);
+  let joined = parts.shift()?.toString();
+  if (joined) {
+    for (const part of parts.map((p) => p.toString())) {
+      if (part.startsWith(".")) {
+        joined = resolvePath(joined, part);
+      } else if (joined[joined.length - 1] !== "/") {
+        if (part[0] !== "/") {
+          joined += "/" + part;
+        } else {
+          joined += part;
+        }
+      } else {
+        if (part[0] === "/") {
+          joined += part.slice(1);
+        } else {
+          joined += part;
+        }
+      }
+    }
+    if (joined && joined !== "/" && joined.endsWith("/")) {
+      joined = joined.slice(0, joined.length - 1);
+    }
+  }
+  return joined ?? "";
+}
+function resolvePath(base, part) {
+  assertString(base, "Expected `base` to be a string. Got type: %t, value: %v");
+  if (part == null) {
+    part = base;
+    base = "";
+  }
+  if (part.startsWith("/")) {
+    return part;
+  }
+  let resolved = base;
+  while (true) {
+    if (part.startsWith("..")) {
+      for (let i = resolved.length; i > 0; --i) {
+        if (resolved[i] === "/" || i === 0) {
+          resolved = resolved.slice(0, i);
+          part = part.replace(/^\.\.\/?/, "");
+          break;
+        }
+      }
+    } else if (part.startsWith(".")) {
+      part = part.replace(/^\.\/?/, "");
+    } else {
+      break;
+    }
+  }
+  return joinPath([resolved, part]);
+}
+function parseQueryParams(query) {
+  if (!query)
+    return {};
+  const entries = query.split("&").filter((x) => x.trim() !== "").map((entry) => {
+    const [key, value] = entry.split("=").map((x) => x.trim());
+    if (value.toLowerCase() === "true") {
+      return [key, true];
+    }
+    if (value.toLowerCase() === "false") {
+      return [key, false];
+    }
+    if (!isNaN(Number(value))) {
+      return [key, Number(value)];
+    }
+    return [key, value];
+  });
+  return Object.fromEntries(entries);
+}
+function matchRoutes(routes, url, options = {}) {
+  const [path, query] = url.split("?");
+  const parts = splitPath(path);
+  routes:
+    for (const route of routes) {
+      const { fragments } = route;
+      const hasWildcard = fragments[fragments.length - 1]?.type === 3 /* Wildcard */;
+      if (!hasWildcard && fragments.length !== parts.length) {
+        continue routes;
+      }
+      if (options.willMatch && !options.willMatch(route)) {
+        continue routes;
+      }
+      const matched = [];
+      fragments:
+        for (let i = 0; i < fragments.length; i++) {
+          const part = parts[i];
+          const frag = fragments[i];
+          if (part == null && frag.type !== 3 /* Wildcard */) {
+            continue routes;
+          }
+          switch (frag.type) {
+            case 1 /* Literal */:
+              if (frag.name.toLowerCase() === part.toLowerCase()) {
+                matched.push(frag);
+                break;
+              } else {
+                continue routes;
+              }
+            case 2 /* Param */:
+              matched.push({ ...frag, value: part });
+              break;
+            case 3 /* Wildcard */:
+              matched.push({ ...frag, value: parts.slice(i).join("/") });
+              break fragments;
+            case 4 /* NumericParam */:
+              if (!isNaN(Number(part))) {
+                matched.push({ ...frag, value: Number(part) });
+                break;
+              } else {
+                continue routes;
+              }
+            default:
+              throw new Error(`Unknown fragment type: ${frag.type}`);
+          }
+        }
+      const params = /* @__PURE__ */ Object.create(null);
+      for (const frag of matched) {
+        if (frag.type === 2 /* Param */) {
+          params[frag.name] = decodeURIComponent(frag.value);
+        }
+        if (frag.type === 4 /* NumericParam */) {
+          params[frag.name] = frag.value;
+        }
+        if (frag.type === 3 /* Wildcard */) {
+          params.wildcard = "/" + decodeURIComponent(frag.value);
+        }
+      }
+      return {
+        path: "/" + matched.map((f) => f.value).join("/"),
+        pattern: "/" + fragments.map((f) => {
+          if (f.type === 2 /* Param */) {
+            return `{${f.name}}`;
+          }
+          if (f.type === 4 /* NumericParam */) {
+            return `{#${f.name}}`;
+          }
+          return f.name;
+        }).join("/"),
+        params,
+        query: parseQueryParams(query),
+        meta: route.meta
+      };
+    }
+}
+function sortRoutes(routes) {
+  const withoutParams = [];
+  const withNumericParams = [];
+  const withParams = [];
+  const wildcard = [];
+  for (const route of routes) {
+    const { fragments } = route;
+    if (fragments.some((f) => f.type === 3 /* Wildcard */)) {
+      wildcard.push(route);
+    } else if (fragments.some((f) => f.type === 4 /* NumericParam */)) {
+      withNumericParams.push(route);
+    } else if (fragments.some((f) => f.type === 2 /* Param */)) {
+      withParams.push(route);
+    } else {
+      withoutParams.push(route);
+    }
+  }
+  const bySizeDesc = (a, b) => {
+    if (a.fragments.length > b.fragments.length) {
+      return -1;
+    } else {
+      return 1;
+    }
+  };
+  withoutParams.sort(bySizeDesc);
+  withNumericParams.sort(bySizeDesc);
+  withParams.sort(bySizeDesc);
+  wildcard.sort(bySizeDesc);
+  return [...withoutParams, ...withNumericParams, ...withParams, ...wildcard];
+}
+function patternToFragments(pattern) {
+  const parts = splitPath(pattern);
+  const fragments = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === "*") {
+      if (i !== parts.length - 1) {
+        throw new Error(
+          `Wildcard must be at the end of a pattern. Received: ${pattern}`
+        );
+      }
+      fragments.push({
+        type: 3 /* Wildcard */,
+        name: "*",
+        value: null
+      });
+    } else if (part.at(0) === "{" && part.at(-1) === "}") {
+      fragments.push({
+        type: part[1] === "#" ? 4 /* NumericParam */ : 2 /* Param */,
+        name: part[1] === "#" ? part.slice(2, -1) : part.slice(1, -1),
+        value: null
+      });
+    } else {
+      fragments.push({
+        type: 1 /* Literal */,
+        name: part,
+        value: part
+      });
+    }
+  }
+  return fragments;
+}
+
 // src/stores/router.ts
 var DefaultView = (_, ctx) => ctx.outlet();
 function RouterStore(ctx) {