@jondotsoy/configs 0.1.0

package/dist/sources/file.js

@@ -0,0 +1,278 @@
+// src/sources/file.ts
+import { watch } from "node:fs";
+import { readFile } from "node:fs/promises";
+
+// src/utils/store.ts
+class Store {
+  value;
+  subscribers = new Set;
+  cleanups = new Map;
+  mountListeners = new Set;
+  unmountListeners = new Set;
+  constructor(initial) {
+    this.value = initial;
+  }
+  get() {
+    return this.value;
+  }
+  set(next) {
+    this.value = next;
+    for (const subscriber of this.subscribers) {
+      this.runSubscriber(subscriber, this.value);
+    }
+  }
+  subscribe(subscriber) {
+    this.addSubscriber(subscriber);
+    this.runSubscriber(subscriber, this.value);
+    return () => this.removeSubscriber(subscriber);
+  }
+  listen(subscriber) {
+    this.addSubscriber(subscriber);
+    return () => this.removeSubscriber(subscriber);
+  }
+  runSubscriber(subscriber, value) {
+    const cleanup = subscriber(value);
+    if (typeof cleanup === "function")
+      this.cleanups.set(subscriber, cleanup);
+  }
+  onMount(listener) {
+    this.mountListeners.add(listener);
+    return () => {
+      this.mountListeners.delete(listener);
+    };
+  }
+  onUnmount(listener) {
+    this.unmountListeners.add(listener);
+    return () => {
+      this.unmountListeners.delete(listener);
+    };
+  }
+  addSubscriber(subscriber) {
+    const wasEmpty = this.subscribers.size === 0;
+    if (wasEmpty) {
+      for (const listener of this.mountListeners)
+        listener();
+    }
+    this.subscribers.add(subscriber);
+  }
+  removeSubscriber(subscriber) {
+    if (!this.subscribers.delete(subscriber))
+      return;
+    const cleanup = this.cleanups.get(subscriber);
+    this.cleanups.delete(subscriber);
+    cleanup?.();
+    if (this.subscribers.size === 0) {
+      for (const listener of this.unmountListeners)
+        listener();
+    }
+  }
+  static onMount(store, callback) {
+    let cleanup;
+    const unsubMount = store.onMount(() => {
+      cleanup = callback();
+    });
+    const unsubUnmount = store.onUnmount(() => {
+      cleanup?.();
+      cleanup = undefined;
+    });
+    return () => {
+      cleanup?.();
+      cleanup = undefined;
+      unsubMount();
+      unsubUnmount();
+    };
+  }
+}
+function create(initial) {
+  return new Store(initial);
+}
+function computed(source, selector) {
+  const result = new Store(selector(source.get()));
+  Store.onMount(result, () => {
+    return source.subscribe((value) => {
+      result.set(selector(value));
+    });
+  });
+  return result;
+}
+var store = { create, computed, onMount: Store.onMount };
+
+// src/sources/source.ts
+class Source {
+  underlying;
+  store = new Store(null);
+  closed = false;
+  closePromise;
+  startPromise;
+  constructor(underlying) {
+    this.underlying = underlying;
+    const control = {
+      set: (value) => {
+        if (this.closed)
+          return;
+        const next = this.underlying.reduce ? this.underlying.reduce(value, this.store.get()) : value;
+        this.store.set(next);
+      },
+      close: () => {
+        this.close();
+      }
+    };
+    this.startPromise = Promise.resolve().then(() => underlying.start(control)).then(() => {
+      return;
+    });
+    this.startPromise.catch(() => {});
+  }
+  async open() {
+    await this.startPromise;
+    return this.store;
+  }
+  close() {
+    if (!this.closePromise) {
+      this.closed = true;
+      this.closePromise = Promise.resolve(this.underlying.close?.()).then(() => {
+        return;
+      }, () => {
+        return;
+      });
+    }
+    return this.closePromise;
+  }
+}
+
+// src/utils/dotenv.ts
+var QUOTES = ['"', "'", "`"];
+function extractQuoted(value, quote) {
+  let i = 1;
+  while (i < value.length) {
+    const char = value[i];
+    if (char === "\\" && i + 1 < value.length) {
+      i += 2;
+      continue;
+    }
+    if (char === quote)
+      return value.slice(1, i);
+    i++;
+  }
+  return;
+}
+function unescapeQuoted(content, quote) {
+  if (quote !== '"')
+    return content;
+  return content.replace(/\\n/g, `
+`).replace(/\\r/g, "\r");
+}
+function stripInlineComment(value) {
+  const match = value.match(/(^|\s)#/);
+  if (!match)
+    return value;
+  return value.slice(0, match.index).trimEnd();
+}
+function parseLine(line) {
+  const eq = line.indexOf("=");
+  if (eq === -1)
+    return;
+  const key = line.slice(0, eq).trim();
+  const rawValue = line.slice(eq + 1).trim();
+  if (rawValue.length >= 2 && QUOTES.includes(rawValue[0])) {
+    const quote = rawValue[0];
+    const quoted = extractQuoted(rawValue, quote);
+    if (quoted !== undefined)
+      return [key, unescapeQuoted(quoted, quote)];
+  }
+  return [key, stripInlineComment(rawValue)];
+}
+function parse(text) {
+  const result = {};
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (line === "" || line.startsWith("#"))
+      continue;
+    const parsed = parseLine(line);
+    if (!parsed)
+      continue;
+    const [key, value] = parsed;
+    result[key] = value;
+  }
+  return result;
+}
+var DotEnv = { parse };
+
+// src/sources/file.ts
+function detectFormat(path) {
+  const pathname = path instanceof URL ? path.pathname : path;
+  if (pathname.endsWith(".json"))
+    return "json";
+  if (pathname.endsWith(".env"))
+    return "env";
+  return;
+}
+function parseFile(format, text) {
+  switch (format) {
+    case "json":
+      return JSON.parse(text);
+    case "env":
+      return DotEnv.parse(text);
+  }
+}
+function selectTreePath(data, treePath) {
+  let node = data;
+  for (const key of treePath) {
+    if (typeof node !== "object" || node === null)
+      return;
+    node = node[key];
+  }
+  return node;
+}
+function fileSource(path, options = {}) {
+  const shouldWatch = options.watch ?? true;
+  const treePath = options.treePath ?? [];
+  let watcher;
+  return new Source({
+    async start(control) {
+      const format = detectFormat(path);
+      if (!format) {
+        console.error(`fileSource: unrecognized file extension for "${path}"`);
+        control.close();
+        return;
+      }
+      async function readOnce() {
+        let text;
+        try {
+          text = await readFile(path, "utf8");
+        } catch (error) {
+          console.error(`fileSource: failed to read "${path}"`, error);
+          return false;
+        }
+        let parsed;
+        try {
+          parsed = parseFile(format, text);
+        } catch (error) {
+          console.error(`fileSource: failed to parse "${path}" as ${format}`, error);
+          return false;
+        }
+        const selected = selectTreePath(parsed, treePath);
+        if (selected === undefined) {
+          console.error(`fileSource: treePath [${treePath.map((k) => JSON.stringify(k)).join(", ")}] did not resolve to anything in "${path}"`);
+          control.set({});
+          return true;
+        }
+        control.set(selected);
+        return true;
+      }
+      await readOnce();
+      if (!shouldWatch) {
+        control.close();
+        return;
+      }
+      watcher = watch(path, { persistent: false }, () => {
+        readOnce();
+      });
+    },
+    close() {
+      watcher?.close();
+    }
+  });
+}
+export {
+  fileSource
+};

package/dist/sources/literal.d.ts

@@ -0,0 +1,3 @@
+import { Source } from "./source";
+/** A `Source` that publishes a single static `value` immediately, then closes. Useful for hardcoded defaults, a static fallback tree, or tests. */
+export declare function literalSource<T = unknown>(value: T): Source<T>;

package/dist/sources/literal.js

@@ -0,0 +1,149 @@
+// src/utils/store.ts
+class Store {
+  value;
+  subscribers = new Set;
+  cleanups = new Map;
+  mountListeners = new Set;
+  unmountListeners = new Set;
+  constructor(initial) {
+    this.value = initial;
+  }
+  get() {
+    return this.value;
+  }
+  set(next) {
+    this.value = next;
+    for (const subscriber of this.subscribers) {
+      this.runSubscriber(subscriber, this.value);
+    }
+  }
+  subscribe(subscriber) {
+    this.addSubscriber(subscriber);
+    this.runSubscriber(subscriber, this.value);
+    return () => this.removeSubscriber(subscriber);
+  }
+  listen(subscriber) {
+    this.addSubscriber(subscriber);
+    return () => this.removeSubscriber(subscriber);
+  }
+  runSubscriber(subscriber, value) {
+    const cleanup = subscriber(value);
+    if (typeof cleanup === "function")
+      this.cleanups.set(subscriber, cleanup);
+  }
+  onMount(listener) {
+    this.mountListeners.add(listener);
+    return () => {
+      this.mountListeners.delete(listener);
+    };
+  }
+  onUnmount(listener) {
+    this.unmountListeners.add(listener);
+    return () => {
+      this.unmountListeners.delete(listener);
+    };
+  }
+  addSubscriber(subscriber) {
+    const wasEmpty = this.subscribers.size === 0;
+    if (wasEmpty) {
+      for (const listener of this.mountListeners)
+        listener();
+    }
+    this.subscribers.add(subscriber);
+  }
+  removeSubscriber(subscriber) {
+    if (!this.subscribers.delete(subscriber))
+      return;
+    const cleanup = this.cleanups.get(subscriber);
+    this.cleanups.delete(subscriber);
+    cleanup?.();
+    if (this.subscribers.size === 0) {
+      for (const listener of this.unmountListeners)
+        listener();
+    }
+  }
+  static onMount(store, callback) {
+    let cleanup;
+    const unsubMount = store.onMount(() => {
+      cleanup = callback();
+    });
+    const unsubUnmount = store.onUnmount(() => {
+      cleanup?.();
+      cleanup = undefined;
+    });
+    return () => {
+      cleanup?.();
+      cleanup = undefined;
+      unsubMount();
+      unsubUnmount();
+    };
+  }
+}
+function create(initial) {
+  return new Store(initial);
+}
+function computed(source, selector) {
+  const result = new Store(selector(source.get()));
+  Store.onMount(result, () => {
+    return source.subscribe((value) => {
+      result.set(selector(value));
+    });
+  });
+  return result;
+}
+var store = { create, computed, onMount: Store.onMount };
+
+// src/sources/source.ts
+class Source {
+  underlying;
+  store = new Store(null);
+  closed = false;
+  closePromise;
+  startPromise;
+  constructor(underlying) {
+    this.underlying = underlying;
+    const control = {
+      set: (value) => {
+        if (this.closed)
+          return;
+        const next = this.underlying.reduce ? this.underlying.reduce(value, this.store.get()) : value;
+        this.store.set(next);
+      },
+      close: () => {
+        this.close();
+      }
+    };
+    this.startPromise = Promise.resolve().then(() => underlying.start(control)).then(() => {
+      return;
+    });
+    this.startPromise.catch(() => {});
+  }
+  async open() {
+    await this.startPromise;
+    return this.store;
+  }
+  close() {
+    if (!this.closePromise) {
+      this.closed = true;
+      this.closePromise = Promise.resolve(this.underlying.close?.()).then(() => {
+        return;
+      }, () => {
+        return;
+      });
+    }
+    return this.closePromise;
+  }
+}
+
+// src/sources/literal.ts
+function literalSource(value) {
+  return new Source({
+    start(control) {
+      control.set(value);
+      control.close();
+    }
+  });
+}
+export {
+  literalSource
+};

package/dist/sources/source.d.ts

@@ -0,0 +1,24 @@
+import { Store } from "../utils/store";
+import type { UnderlyingSource } from "../types";
+/**
+ * A read-only, async config source modeled after `ReadableStream`: `start(control)` runs once,
+ * pushing whole-tree snapshots via `control.set(value)` and signaling `control.close()` when done.
+ * `open()` resolves once `start()` itself finishes running, with the live `Store` it populated.
+ * With `reduce`, every `control.set(value)` runs `value` (and the last published value) through it
+ * first, so `start()` can hand it partial patches instead of whole snapshots.
+ */
+export declare class Source<T = unknown> {
+    private readonly underlying;
+    private readonly store;
+    private closed;
+    private closePromise;
+    private readonly startPromise;
+    constructor(underlying: UnderlyingSource<T>);
+    open(): Promise<Store<T | null>>;
+    /**
+     * Closes the source: runs its `close()` hook (if any) at most once, whether triggered from
+     * within `start()` (via `control.close()`) or from the outside. Safe to call any number of
+     * times, before or after `open()` — every call resolves once the same underlying close settles.
+     */
+    close(): Promise<void>;
+}

package/dist/sources/sse.d.ts

@@ -0,0 +1,22 @@
+import { Source } from "./source";
+export interface SseSourceOptions {
+    url: string | URL;
+    method?: string;
+    headers?: Bun.HeadersInit;
+}
+/**
+ * A `Source` that connects to a Server-Sent Events endpoint. Every message tries to parse as
+ * JSON; a successful parse of a plain object is published via `control.set`, which — through this
+ * source's `reduce` — is applied as a shallow patch onto the config tree accumulated so far (new
+ * fields are added, existing ones overwritten, everything else kept) — e.g. `{"port":3000}` then
+ * `{"host":"10.0.0.1"}` end up as `{ port: 3000, host: "10.0.0.1" }`.
+ * A message that isn't valid JSON, or doesn't parse to a plain object, is logged via
+ * `console.error` and skipped, without disturbing the accumulated state or the connection.
+ *
+ * `start()` only resolves once the first message has been applied (or the connection closed
+ * without ever receiving one) — so `open()` always hands back a `Store` with data already in it,
+ * not one waiting on a race. The connection then stays open in the background, applying further
+ * messages as patches, until the resource closes the stream — or `close()` is called on the
+ * returned `Source` (or via a config tree's own `close()`), which aborts the connection.
+ */
+export declare function sseSource<T = unknown>(options: SseSourceOptions): Source<T>;

package/dist/sources/sse.js

@@ -0,0 +1,236 @@
+// src/utils/store.ts
+class Store {
+  value;
+  subscribers = new Set;
+  cleanups = new Map;
+  mountListeners = new Set;
+  unmountListeners = new Set;
+  constructor(initial) {
+    this.value = initial;
+  }
+  get() {
+    return this.value;
+  }
+  set(next) {
+    this.value = next;
+    for (const subscriber of this.subscribers) {
+      this.runSubscriber(subscriber, this.value);
+    }
+  }
+  subscribe(subscriber) {
+    this.addSubscriber(subscriber);
+    this.runSubscriber(subscriber, this.value);
+    return () => this.removeSubscriber(subscriber);
+  }
+  listen(subscriber) {
+    this.addSubscriber(subscriber);
+    return () => this.removeSubscriber(subscriber);
+  }
+  runSubscriber(subscriber, value) {
+    const cleanup = subscriber(value);
+    if (typeof cleanup === "function")
+      this.cleanups.set(subscriber, cleanup);
+  }
+  onMount(listener) {
+    this.mountListeners.add(listener);
+    return () => {
+      this.mountListeners.delete(listener);
+    };
+  }
+  onUnmount(listener) {
+    this.unmountListeners.add(listener);
+    return () => {
+      this.unmountListeners.delete(listener);
+    };
+  }
+  addSubscriber(subscriber) {
+    const wasEmpty = this.subscribers.size === 0;
+    if (wasEmpty) {
+      for (const listener of this.mountListeners)
+        listener();
+    }
+    this.subscribers.add(subscriber);
+  }
+  removeSubscriber(subscriber) {
+    if (!this.subscribers.delete(subscriber))
+      return;
+    const cleanup = this.cleanups.get(subscriber);
+    this.cleanups.delete(subscriber);
+    cleanup?.();
+    if (this.subscribers.size === 0) {
+      for (const listener of this.unmountListeners)
+        listener();
+    }
+  }
+  static onMount(store, callback) {
+    let cleanup;
+    const unsubMount = store.onMount(() => {
+      cleanup = callback();
+    });
+    const unsubUnmount = store.onUnmount(() => {
+      cleanup?.();
+      cleanup = undefined;
+    });
+    return () => {
+      cleanup?.();
+      cleanup = undefined;
+      unsubMount();
+      unsubUnmount();
+    };
+  }
+}
+function create(initial) {
+  return new Store(initial);
+}
+function computed(source, selector) {
+  const result = new Store(selector(source.get()));
+  Store.onMount(result, () => {
+    return source.subscribe((value) => {
+      result.set(selector(value));
+    });
+  });
+  return result;
+}
+var store = { create, computed, onMount: Store.onMount };
+
+// src/sources/source.ts
+class Source {
+  underlying;
+  store = new Store(null);
+  closed = false;
+  closePromise;
+  startPromise;
+  constructor(underlying) {
+    this.underlying = underlying;
+    const control = {
+      set: (value) => {
+        if (this.closed)
+          return;
+        const next = this.underlying.reduce ? this.underlying.reduce(value, this.store.get()) : value;
+        this.store.set(next);
+      },
+      close: () => {
+        this.close();
+      }
+    };
+    this.startPromise = Promise.resolve().then(() => underlying.start(control)).then(() => {
+      return;
+    });
+    this.startPromise.catch(() => {});
+  }
+  async open() {
+    await this.startPromise;
+    return this.store;
+  }
+  close() {
+    if (!this.closePromise) {
+      this.closed = true;
+      this.closePromise = Promise.resolve(this.underlying.close?.()).then(() => {
+        return;
+      }, () => {
+        return;
+      });
+    }
+    return this.closePromise;
+  }
+}
+
+// src/sources/sse.ts
+function isPatch(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractData(rawEvent) {
+  const dataLines = rawEvent.split(`
+`).filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).replace(/^ /, ""));
+  return dataLines.length > 0 ? dataLines.join(`
+`) : null;
+}
+async function readEvents(body, onEvent) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      let boundary;
+      while ((boundary = buffer.indexOf(`
+
+`)) !== -1) {
+        onEvent(buffer.slice(0, boundary));
+        buffer = buffer.slice(boundary + 2);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function sseSource(options) {
+  const { url, method = "GET", headers } = options;
+  const abortController = new AbortController;
+  return new Source({
+    async start(control) {
+      let response;
+      try {
+        response = await fetch(url, { method, headers, signal: abortController.signal });
+      } catch (error) {
+        if (!abortController.signal.aborted) {
+          console.error(`sseSource: failed to connect to "${url}"`, error);
+        }
+        control.close();
+        return;
+      }
+      if (!response.ok || !response.body) {
+        console.error(`sseSource: received ${response.status} ${response.statusText} from "${url}"`);
+        control.close();
+        return;
+      }
+      await new Promise((resolveFirstMessage) => {
+        let settled = false;
+        const settle = () => {
+          if (settled)
+            return;
+          settled = true;
+          resolveFirstMessage();
+        };
+        readEvents(response.body, (rawEvent) => {
+          const raw = extractData(rawEvent);
+          if (raw === null || raw.trim() === "")
+            return;
+          let parsed;
+          try {
+            parsed = JSON.parse(raw);
+          } catch (error) {
+            console.error(`sseSource: message from "${url}" is not valid JSON`, error);
+            return;
+          }
+          if (!isPatch(parsed)) {
+            console.error(`sseSource: message from "${url}" did not parse to a JSON object`, parsed);
+            return;
+          }
+          control.set(parsed);
+          settle();
+        }).catch((error) => {
+          if (!abortController.signal.aborted) {
+            console.error(`sseSource: connection to "${url}" ended with an error`, error);
+          }
+        }).finally(() => {
+          control.close();
+          settle();
+        });
+      });
+    },
+    reduce: (patch, previous) => ({
+      ...previous ?? {},
+      ...patch
+    }),
+    close() {
+      abortController.abort();
+    }
+  });
+}
+export {
+  sseSource
+};

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export type { SourceControl, UnderlyingSource } from "./source";
+export type {} from "./schema";