Skip to content

A spy satellite simulator in your browser, except the data is real. Live open source spatial intelligence on a photorealistic 3D globe.

3.2 KB
Raw Blame
/** Copy plain product data so a subscriber cannot mutate its owner's state. */
function copyState(value, ancestors = new Set()) {
  if (value === null) return value;
  if (typeof value !== 'object') {
    if (['string', 'number', 'boolean', 'undefined'].includes(typeof value))
      return value;
    throw new TypeError('Product state must contain plain data');
  }
  if (ancestors.has(value)) throw new TypeError('Circular product state');
  if (
    !Array.isArray(value) &&
    Object.getPrototypeOf(value) !== Object.prototype &&
    Object.getPrototypeOf(value) !== null
  ) {
    throw new TypeError('Product state must contain plain records');
  }
  const next = new Set(ancestors).add(value);
  const copy = Array.isArray(value)
    ? value.map((item) => copyState(item, next))
    : Object.fromEntries(
        Object.entries(value).map(([key, item]) => [
          key,
          copyState(item, next),
        ]),
      );
  return Object.freeze(copy);
}

/**
 * Publish immutable snapshots and ordinary action outcomes synchronously.
 * Reentrant publications retain order. New subscribers start at current state;
 * removed subscribers and destroyed channels cannot receive queued work.
 */
export function createStateChannel(readSnapshot) {
  const listeners = new Set();
  const pending = [];
  let revision = 0;
  let delivering = false;
  let destroyed = false;
  let lastSnapshot = null;
  const getSnapshot = () => {
    if (!destroyed) lastSnapshot = copyState(readSnapshot());
    return lastSnapshot;
  };
  const deliver = (entry, notification) => {
    try {
      entry.listener(notification);
    } catch {
      console.error('Product state listener failed');
    }
  };
  return Object.freeze({
    getSnapshot,
    subscribe(listener, { emitCurrent = true } = {}) {
      if (typeof listener !== 'function')
        throw new TypeError('Expected a state listener');
      if (destroyed) return () => {};
      const state = emitCurrent ? getSnapshot() : null;
      const entry = { listener, revision };
      listeners.add(entry);
      if (emitCurrent)
        deliver(
          entry,
          Object.freeze({
            state,
            change: null,
            revision,
            initial: true,
          }),
        );
      return () => listeners.delete(entry);
    },
    publish(change = null) {
      if (destroyed) return false;
      pending.push(
        Object.freeze({
          state: getSnapshot(),
          change: copyState(change),
          revision: ++revision,
          initial: false,
        }),
      );
      if (delivering) return true;
      delivering = true;
      try {
        while (!destroyed && pending.length) {
          const notification = pending.shift();
          for (const entry of [...listeners]) {
            if (
              destroyed ||
              !listeners.has(entry) ||
              entry.revision >= notification.revision
            )
              continue;
            entry.revision = notification.revision;
            deliver(entry, notification);
          }
        }
      } finally {
        delivering = false;
      }
      return true;
    },
    destroy() {
      if (destroyed) return;
      destroyed = true;
      listeners.clear();
      pending.length = 0;
    },
  });
}