@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/_browser-chunks/chunk-OD6IBQCC.js

@@ -0,0 +1,117 @@
+// src/channels/main.ts
+var isMulti = (args) => args.transports !== void 0, generateRandomId = () => Math.random().toString(16).slice(2), Channel = class {
+  constructor(input = {}) {
+    this.sender = generateRandomId();
+    this.events = {};
+    this.data = {};
+    this.transports = [];
+    this.isAsync = input.async || !1, isMulti(input) ? (this.transports = input.transports || [], this.transports.forEach((t) => {
+      t.setHandler((event) => this.handleEvent(event));
+    })) : this.transports = input.transport ? [input.transport] : [], this.transports.forEach((t) => {
+      t.setHandler((event) => this.handleEvent(event));
+    });
+  }
+  get hasTransport() {
+    return this.transports.length > 0;
+  }
+  addListener(eventName, listener) {
+    this.events[eventName] = this.events[eventName] || [], this.events[eventName].push(listener);
+  }
+  emit(eventName, ...args) {
+    let event = { type: eventName, args, from: this.sender }, options = {};
+    args.length >= 1 && args[0] && args[0].options && (options = args[0].options);
+    let handler = () => {
+      this.transports.forEach((t) => {
+        t.send(event, options);
+      }), this.handleEvent(event);
+    };
+    this.isAsync ? setImmediate(handler) : handler();
+  }
+  last(eventName) {
+    return this.data[eventName];
+  }
+  eventNames() {
+    return Object.keys(this.events);
+  }
+  listenerCount(eventName) {
+    let listeners = this.listeners(eventName);
+    return listeners ? listeners.length : 0;
+  }
+  listeners(eventName) {
+    return this.events[eventName] || void 0;
+  }
+  once(eventName, listener) {
+    let onceListener = this.onceListener(eventName, listener);
+    this.addListener(eventName, onceListener);
+  }
+  removeAllListeners(eventName) {
+    eventName ? this.events[eventName] && delete this.events[eventName] : this.events = {};
+  }
+  removeListener(eventName, listener) {
+    let listeners = this.listeners(eventName);
+    listeners && (this.events[eventName] = listeners.filter((l) => l !== listener));
+  }
+  on(eventName, listener) {
+    this.addListener(eventName, listener);
+  }
+  off(eventName, listener) {
+    this.removeListener(eventName, listener);
+  }
+  /**
+   * Deliver an event to local listeners without sending it to this channel's transports.
+   */
+  receive(event) {
+    this.handleEvent(event);
+  }
+  handleEvent(event) {
+    let listeners = this.listeners(event.type);
+    listeners && listeners.length && listeners.forEach((fn) => {
+      fn.apply(event, event.args);
+    }), this.data[event.type] = event.args;
+  }
+  onceListener(eventName, listener) {
+    let onceListener = (...args) => (this.removeListener(eventName, onceListener), listener(...args));
+    return onceListener;
+  }
+};
+
+// src/channels/channel-slot.ts
+var channel;
+function syncGlobalSlot(next) {
+  globalThis.__STORYBOOK_ADDONS_CHANNEL__ = next;
+}
+function getChannel() {
+  let fromGlobal = globalThis.__STORYBOOK_ADDONS_CHANNEL__;
+  return fromGlobal && (channel = fromGlobal), channel ?? null;
+}
+function requireChannel() {
+  let installed = getChannel();
+  if (!installed)
+    throw new Error(
+      "Forkbook addons channel is not installed in this runtime. Install it via setChannel() or addons.setChannel() at the runtime entry point before registering services or emitting events."
+    );
+  return installed;
+}
+function setChannel(next) {
+  channel = next ?? void 0, syncGlobalSlot(channel);
+}
+function clearChannel() {
+  setChannel(null);
+}
+function installNoopChannel() {
+  setChannel(new Channel({}));
+}
+function ensureChannel() {
+  getChannel() || installNoopChannel();
+}
+typeof window > "u" && ensureChannel();
+
+export {
+  Channel,
+  getChannel,
+  requireChannel,
+  setChannel,
+  clearChannel,
+  installNoopChannel,
+  ensureChannel
+};

package/dist/_browser-chunks/chunk-ODVJ3XZJ.js

@@ -0,0 +1,157 @@
+import {
+  mapValues,
+  pickBy
+} from "./chunk-2JDQ35OA.js";
+import {
+  isPlainObject
+} from "./chunk-JWSKPMPC.js";
+
+// src/preview-api/modules/store/parameters.ts
+var combineParameters = (...parameterSets) => {
+  let mergeKeys = {}, definedParametersSets = parameterSets.filter(Boolean), combined = definedParametersSets.reduce((acc, parameters) => (Object.entries(parameters).forEach(([key, value]) => {
+    let existing = acc[key];
+    Array.isArray(value) || typeof existing > "u" ? acc[key] = value : isPlainObject(value) && isPlainObject(existing) ? mergeKeys[key] = !0 : typeof value < "u" && (acc[key] = value);
+  }), acc), {});
+  return Object.keys(mergeKeys).forEach((key) => {
+    let mergeValues = definedParametersSets.filter(Boolean).map((p) => p[key]).filter((value) => typeof value < "u");
+    mergeValues.every((value) => isPlainObject(value)) ? combined[key] = combineParameters(...mergeValues) : combined[key] = mergeValues[mergeValues.length - 1];
+  }), combined;
+};
+
+// src/preview-api/modules/store/filterArgTypes.ts
+var matches = (name, descriptor) => Array.isArray(descriptor) ? descriptor.includes(name) : name.match(descriptor), filterArgTypes = (argTypes, include, exclude) => !include && !exclude ? argTypes : argTypes && pickBy(argTypes, (argType, key) => {
+  let name = argType.name || key.toString();
+  return !!(!include || matches(name, include)) && (!exclude || !matches(name, exclude));
+});
+
+// src/preview-api/modules/store/inferControls.ts
+import { logger } from "@aussieljk/forkbook/internal/client-logger";
+var inferControl = (argType, name, matchers) => {
+  let { type, options } = argType;
+  if (type) {
+    if (matchers.color && matchers.color.test(name)) {
+      let controlType = type.name;
+      if (controlType === "string")
+        return { control: { type: "color" } };
+      controlType !== "enum" && logger.warn(
+        `Addon controls: Control of type color only supports string, received "${controlType}" instead`
+      );
+    }
+    if (matchers.date && matchers.date.test(name))
+      return { control: { type: "date" } };
+    switch (type.name) {
+      case "array":
+        return { control: { type: "object" } };
+      case "boolean":
+        return { control: { type: "boolean" } };
+      case "string":
+        return { control: { type: "text" } };
+      case "number":
+        return { control: { type: "number" } };
+      case "enum": {
+        let { value } = type;
+        return { control: { type: value?.length <= 5 ? "radio" : "select" }, options: value };
+      }
+      case "function":
+      case "symbol":
+        return null;
+      default:
+        return { control: { type: options ? "select" : "object" } };
+    }
+  }
+}, inferControls = (context) => {
+  let {
+    argTypes,
+    parameters: { __isArgsStory, controls: { include = null, exclude = null, matchers = {} } = {} }
+  } = context;
+  if (!__isArgsStory)
+    return argTypes;
+  let filteredArgTypes = filterArgTypes(argTypes, include, exclude), withControls = mapValues(filteredArgTypes, (argType, name) => argType?.type && inferControl(argType, name.toString(), matchers));
+  return combineParameters(withControls, filteredArgTypes);
+};
+inferControls.secondPass = !0;
+
+// src/preview-api/modules/store/inferArgTypes.ts
+import { logger as logger2 } from "@aussieljk/forkbook/internal/client-logger";
+import { dedent } from "ts-dedent";
+var inferType = (value, name, visited, cache) => {
+  let type = typeof value;
+  switch (type) {
+    case "boolean":
+    case "string":
+    case "number":
+    case "function":
+    case "symbol":
+      return { name: type };
+    default:
+      break;
+  }
+  if (value) {
+    if (cache.has(value))
+      return cache.get(value);
+    if (visited.has(value))
+      return logger2.warn(dedent`
+        We've detected a cycle in arg '${name}'. Args should be JSON-serializable.
+
+        Consider using the mapping feature or fully custom args:
+        - Mapping: https://storybook.js.org/docs/writing-stories/args#mapping-to-complex-arg-values
+        - Custom args: https://storybook.js.org/docs/essentials/controls#fully-custom-args
+      `), { name: "other", value: "cyclic object" };
+    visited.add(value);
+    let result;
+    return Array.isArray(value) ? result = { name: "array", value: value.length > 0 ? inferType(value[0], name, visited, cache) : { name: "other", value: "unknown" } } : result = { name: "object", value: mapValues(value, (field) => inferType(field, name, visited, cache)) }, visited.delete(value), cache.set(value, result), result;
+  }
+  return { name: "object", value: {} };
+}, inferArgTypes = (context) => {
+  let { id, argTypes: userArgTypes = {}, initialArgs = {} } = context, cache = /* @__PURE__ */ new Map(), argTypes = Object.fromEntries(
+    Object.entries(initialArgs).filter(([key]) => !userArgTypes[key]?.type).map(([key, arg]) => [
+      key,
+      {
+        name: key,
+        type: inferType(arg, `${id}.${key}`, /* @__PURE__ */ new Set(), cache)
+      }
+    ])
+  ), userArgTypesNames = mapValues(userArgTypes, (argType, key) => ({
+    name: key
+  }));
+  return combineParameters(argTypes, userArgTypesNames, userArgTypes);
+};
+inferArgTypes.secondPass = !0;
+
+// src/docs-tools/argTypes/docgenServiceArgTypes.ts
+function mergeServiceArgTypes({
+  payload,
+  storyId,
+  parameters,
+  initialArgs,
+  customArgTypes
+}) {
+  let merged = combineParameters(payload?.argTypes ?? {}, customArgTypes ?? {}), withInferredTypes = inferArgTypes({
+    id: storyId,
+    argTypes: merged,
+    initialArgs: initialArgs ?? {}
+  });
+  return inferControls({
+    argTypes: withInferredTypes,
+    // The manager can render this before the preview reports `storyPrepared`, so `parameters` may be
+    // undefined; `inferControls` reads `parameters.__isArgsStory` and would throw. An empty object
+    // makes it a no-op until prepared parameters arrive and trigger a re-render.
+    parameters: parameters ?? {}
+  });
+}
+function getServiceSubcomponentArgTypes(payload) {
+  return Object.fromEntries(
+    Object.entries(payload.subcomponents ?? {}).flatMap(
+      ([name, subcomponent]) => subcomponent.argTypes ? [[name, subcomponent.argTypes]] : []
+    )
+  );
+}
+
+export {
+  combineParameters,
+  inferArgTypes,
+  filterArgTypes,
+  inferControls,
+  mergeServiceArgTypes,
+  getServiceSubcomponentArgTypes
+};

package/dist/_browser-chunks/chunk-OQWFVDIN.js

@@ -0,0 +1,386 @@
+import {
+  UniversalStoreFollowerTimeoutError
+} from "./chunk-RSPAQWVJ.js";
+
+// src/shared/universal-store/index.ts
+import { dedent } from "ts-dedent";
+
+// src/shared/universal-store/first-party-store-ids.ts
+var FIRST_PARTY_STORE_IDS = /* @__PURE__ */ new Set([
+  "@aussieljk/forkbook/status",
+  "@aussieljk/forkbook/test-provider",
+  "@aussieljk/forkbook/test"
+]), isFirstPartyStoreId = (id) => FIRST_PARTY_STORE_IDS.has(id);
+
+// src/shared/universal-store/instances.ts
+var instances = /* @__PURE__ */ new Map();
+
+// src/shared/universal-store/index.ts
+var CHANNEL_EVENT_PREFIX = "UNIVERSAL_STORE:", ProgressState = {
+  PENDING: "PENDING",
+  RESOLVED: "RESOLVED",
+  REJECTED: "REJECTED"
+}, _UniversalStore = class _UniversalStore {
+  constructor(options, environmentOverrides) {
+    /** Enable debug logs for this store */
+    this.debugging = !1;
+    // TODO: narrow type of listeners based on event type
+    this.listeners = /* @__PURE__ */ new Map([["*", /* @__PURE__ */ new Set()]]);
+    /** Gets the current state */
+    this.getState = () => (this.debug("getState", { state: this.state }), this.state);
+    /**
+     * Subscribes to store events
+     *
+     * @returns A function to unsubscribe
+     */
+    this.subscribe = (eventTypeOrListener, maybeListener) => {
+      let subscribesToAllEvents = typeof eventTypeOrListener == "function", eventType = subscribesToAllEvents ? "*" : eventTypeOrListener, listener = subscribesToAllEvents ? eventTypeOrListener : maybeListener;
+      if (this.debug("subscribe", { eventType, listener }), !listener)
+        throw new TypeError(
+          `Missing first subscribe argument, or second if first is the event type, when subscribing to a UniversalStore with id '${this.id}'`
+        );
+      return this.listeners.has(eventType) || this.listeners.set(eventType, /* @__PURE__ */ new Set()), this.listeners.get(eventType).add(listener), () => {
+        this.debug("unsubscribe", { eventType, listener }), this.listeners.has(eventType) && (this.listeners.get(eventType).delete(listener), this.listeners.get(eventType)?.size === 0 && this.listeners.delete(eventType));
+      };
+    };
+    /** Sends a custom event to the other stores */
+    this.send = (event) => {
+      if (this.debug("send", { event }), this.status !== _UniversalStore.Status.READY)
+        throw new TypeError(
+          dedent`Cannot send event before store is ready. You can get the current status with store.status,
+        or await store.readyPromise to wait for the store to be ready before sending events.
+        ${JSON.stringify(
+            {
+              event,
+              id: this.id,
+              actor: this.actor,
+              environment: this.environment
+            },
+            null,
+            2
+          )}`
+        );
+      this.emitToListeners(event, { actor: this.actor }), this.emitToChannel(event, { actor: this.actor });
+    };
+    if (this.debugging = options.debug ?? !1, !_UniversalStore.isInternalConstructing)
+      throw new TypeError(
+        "UniversalStore is not constructable - use UniversalStore.create() instead"
+      );
+    if (_UniversalStore.isInternalConstructing = !1, this.id = options.id, this.actorId = Date.now().toString(36) + Math.random().toString(36).substring(2), this.actorType = options.leader ? _UniversalStore.ActorType.LEADER : _UniversalStore.ActorType.FOLLOWER, this.state = options.initialState, this.channelEventName = `${CHANNEL_EVENT_PREFIX}${this.id}`, this.debug("constructor", {
+      options,
+      environmentOverrides,
+      channelEventName: this.channelEventName
+    }), this.actor.type === _UniversalStore.ActorType.LEADER)
+      this.syncing = {
+        state: ProgressState.RESOLVED,
+        promise: Promise.resolve()
+      };
+    else {
+      let syncingResolve, syncingReject, syncingPromise = new Promise((resolve, reject) => {
+        syncingResolve = () => {
+          this.syncing.state === ProgressState.PENDING && (this.syncing.state = ProgressState.RESOLVED, resolve());
+        }, syncingReject = (reason) => {
+          this.syncing.state === ProgressState.PENDING && (this.syncing.state = ProgressState.REJECTED, reject(reason));
+        };
+      });
+      this.syncing = {
+        state: ProgressState.PENDING,
+        promise: syncingPromise,
+        resolve: syncingResolve,
+        reject: syncingReject
+      };
+    }
+    this.getState = this.getState.bind(this), this.setState = this.setState.bind(this), this.subscribe = this.subscribe.bind(this), this.onStateChange = this.onStateChange.bind(this), this.send = this.send.bind(this), this.emitToChannel = this.emitToChannel.bind(this), this.prepareThis = this.prepareThis.bind(this), this.emitToListeners = this.emitToListeners.bind(this), this.handleChannelEvents = this.handleChannelEvents.bind(this), this.debug = this.debug.bind(this), this.channel = environmentOverrides?.channel ?? _UniversalStore.preparation.channel, this.environment = environmentOverrides?.environment ?? _UniversalStore.preparation.environment, this.channel && this.environment ? (environmentOverrides || _UniversalStore.preparation.resolve({
+      channel: this.channel,
+      environment: this.environment
+    }), this.prepareThis({ channel: this.channel, environment: this.environment })) : _UniversalStore.preparation.promise.then(this.prepareThis);
+  }
+  /** The environment this realm was prepared as, or `undefined` before `__prepare`. */
+  static get preparedEnvironment() {
+    return _UniversalStore.preparation.environment;
+  }
+  static setupPreparationPromise() {
+    let resolveRef, rejectRef, promise = new Promise(
+      (resolve, reject) => {
+        resolveRef = (args) => {
+          resolve(args);
+        }, rejectRef = (...args) => {
+          reject(args);
+        };
+      }
+    );
+    _UniversalStore.preparation = {
+      resolve: resolveRef,
+      reject: rejectRef,
+      promise
+    };
+  }
+  /** The actor object representing the store instance with a unique ID and a type */
+  get actor() {
+    return Object.freeze({
+      id: this.actorId,
+      type: this.actorType,
+      environment: this.environment ?? _UniversalStore.Environment.UNKNOWN
+    });
+  }
+  /**
+   * The current state of the store, that signals both if the store is prepared by Forkbook and
+   * also - in the case of a follower - if the state has been synced with the leader's state.
+   */
+  get status() {
+    if (!this.channel || !this.environment)
+      return _UniversalStore.Status.UNPREPARED;
+    switch (this.syncing?.state) {
+      case ProgressState.PENDING:
+      case void 0:
+        return _UniversalStore.Status.SYNCING;
+      case ProgressState.REJECTED:
+        return _UniversalStore.Status.ERROR;
+      case ProgressState.RESOLVED:
+      default:
+        return _UniversalStore.Status.READY;
+    }
+  }
+  /**
+   * A promise that resolves when the store is fully ready. A leader will be ready when the store
+   * has been prepared by Forkbook, which is almost instantly.
+   *
+   * A follower will be ready when the state has been synced with the leader's state, within a few
+   * hundred milliseconds.
+   */
+  untilReady() {
+    let preparation = this.channel && this.environment ? Promise.resolve() : _UniversalStore.preparation.promise;
+    return Promise.all([preparation, this.syncing?.promise]);
+  }
+  /** Creates a new instance of UniversalStore */
+  static create(options) {
+    if (!options || typeof options?.id != "string")
+      throw new TypeError("id is required and must be a string, when creating a UniversalStore");
+    if (!isFirstPartyStoreId(options.id))
+      throw new TypeError(
+        `UniversalStore is internal to Forkbook and cannot create a store with id "${options.id}"`
+      );
+    options.debug && console.debug(
+      dedent`[UniversalStore]
+        create`,
+      { options }
+    );
+    let existing = instances.get(options.id);
+    if (existing)
+      return console.warn(dedent`UniversalStore with id "${options.id}" already exists in this environment, re-using existing.
+        You should reuse the existing instance instead of trying to create a new one.`), existing;
+    _UniversalStore.isInternalConstructing = !0;
+    let store = new _UniversalStore(options);
+    return instances.set(options.id, store), store;
+  }
+  /**
+   * Used by Forkbook to set the channel for all instances of UniversalStore in the given
+   * environment.
+   *
+   * @internal
+   */
+  static __prepare(channel, environment) {
+    _UniversalStore.preparation.channel = channel, _UniversalStore.preparation.environment = environment, _UniversalStore.preparation.resolve({ channel, environment });
+  }
+  /**
+   * Updates the store's state
+   *
+   * Either a new state or a state updater function can be passed to the method.
+   */
+  setState(updater) {
+    let previousState = this.state, newState = typeof updater == "function" ? updater(previousState) : updater;
+    if (this.debug("setState", { newState, previousState, updater }), this.status !== _UniversalStore.Status.READY)
+      throw new TypeError(
+        dedent`Cannot set state before store is ready. You can get the current status with store.status,
+        or await store.readyPromise to wait for the store to be ready before sending events.
+        ${JSON.stringify(
+          {
+            newState,
+            id: this.id,
+            actor: this.actor,
+            environment: this.environment
+          },
+          null,
+          2
+        )}`
+      );
+    this.state = newState;
+    let event = {
+      type: _UniversalStore.InternalEventType.SET_STATE,
+      payload: {
+        state: newState,
+        previousState
+      }
+    };
+    this.emitToChannel(event, { actor: this.actor }), this.emitToListeners(event, { actor: this.actor });
+  }
+  /**
+   * Subscribes to state changes
+   *
+   * @returns Unsubscribe function
+   */
+  onStateChange(listener) {
+    return this.debug("onStateChange", { listener }), this.subscribe(
+      _UniversalStore.InternalEventType.SET_STATE,
+      ({ payload }, eventInfo) => {
+        listener(payload.state, payload.previousState, eventInfo);
+      }
+    );
+  }
+  emitToChannel(event, eventInfo) {
+    this.debug("emitToChannel", { event, eventInfo, channel: !!this.channel }), this.channel?.emit(this.channelEventName, {
+      event,
+      eventInfo
+    });
+  }
+  prepareThis({
+    channel,
+    environment
+  }) {
+    this.channel = channel, this.environment = environment, this.debug("prepared", { channel: !!channel, environment }), this.channel.on(this.channelEventName, this.handleChannelEvents), this.actor.type === _UniversalStore.ActorType.LEADER ? this.emitToChannel(
+      { type: _UniversalStore.InternalEventType.LEADER_CREATED },
+      { actor: this.actor }
+    ) : (this.emitToChannel(
+      { type: _UniversalStore.InternalEventType.FOLLOWER_CREATED },
+      { actor: this.actor }
+    ), this.emitToChannel(
+      { type: _UniversalStore.InternalEventType.EXISTING_STATE_REQUEST },
+      { actor: this.actor }
+    ), setTimeout(() => {
+      this.syncing.reject(new UniversalStoreFollowerTimeoutError(this.id));
+    }, 1e3));
+  }
+  emitToListeners(event, eventInfo) {
+    let eventTypeListeners = this.listeners.get(event.type), everythingListeners = this.listeners.get("*");
+    this.debug("emitToListeners", {
+      event,
+      eventInfo,
+      eventTypeListeners,
+      everythingListeners
+    }), [...eventTypeListeners ?? [], ...everythingListeners ?? []].forEach(
+      (listener) => listener(event, eventInfo)
+    );
+  }
+  handleChannelEvents(channelEvent) {
+    let { event, eventInfo } = channelEvent;
+    if ([eventInfo.actor.id, eventInfo.forwardingActor?.id].includes(this.actor.id)) {
+      this.debug("handleChannelEvents: Ignoring event from self", { channelEvent });
+      return;
+    } else if (this.syncing?.state === ProgressState.PENDING && event.type !== _UniversalStore.InternalEventType.EXISTING_STATE_RESPONSE) {
+      this.debug("handleChannelEvents: Ignoring event while syncing", { channelEvent });
+      return;
+    }
+    if (this.debug("handleChannelEvents", { channelEvent }), this.actor.type === _UniversalStore.ActorType.LEADER) {
+      let shouldForwardEvent = !0;
+      switch (event.type) {
+        case _UniversalStore.InternalEventType.EXISTING_STATE_REQUEST:
+          shouldForwardEvent = !1;
+          let responseEvent = {
+            type: _UniversalStore.InternalEventType.EXISTING_STATE_RESPONSE,
+            payload: this.state
+          };
+          this.debug("handleChannelEvents: responding to existing state request", {
+            responseEvent
+          }), this.emitToChannel(responseEvent, { actor: this.actor }), this.emitToListeners(responseEvent, { actor: this.actor });
+          break;
+        case _UniversalStore.InternalEventType.LEADER_CREATED:
+          shouldForwardEvent = !1, this.syncing.state = ProgressState.REJECTED, this.debug("handleChannelEvents: erroring due to second leader being created", {
+            event
+          }), console.error(
+            dedent`Detected multiple UniversalStore leaders created with the same id "${this.id}".
+            Only one leader can exists at a time, your stores are now in an invalid state.
+            Leaders detected:
+            this: ${JSON.stringify(this.actor, null, 2)}
+            other: ${JSON.stringify(eventInfo.actor, null, 2)}`
+          );
+          break;
+      }
+      shouldForwardEvent && (this.debug("handleChannelEvents: forwarding event", { channelEvent }), this.emitToChannel(event, { actor: eventInfo.actor, forwardingActor: this.actor }));
+    }
+    if (this.actor.type === _UniversalStore.ActorType.FOLLOWER)
+      switch (event.type) {
+        case _UniversalStore.InternalEventType.EXISTING_STATE_RESPONSE:
+          if (this.debug("handleChannelEvents: Setting state from leader's existing state response", {
+            event
+          }), this.syncing?.state !== ProgressState.PENDING)
+            break;
+          this.syncing.resolve?.();
+          let setStateEvent = {
+            type: _UniversalStore.InternalEventType.SET_STATE,
+            payload: {
+              state: event.payload,
+              previousState: this.state
+            }
+          };
+          this.state = event.payload, this.emitToListeners(setStateEvent, eventInfo);
+          break;
+      }
+    event.type === _UniversalStore.InternalEventType.SET_STATE && (this.debug("handleChannelEvents: Setting state", { event }), this.state = event.payload.state), this.emitToListeners(event, { actor: eventInfo.actor });
+  }
+  debug(message, data) {
+    this.debugging && console.debug(
+      dedent`[UniversalStore::${this.id}::${this.environment ?? _UniversalStore.Environment.UNKNOWN}]
+        ${message}`,
+      JSON.stringify(
+        {
+          data,
+          actor: this.actor,
+          state: this.state,
+          status: this.status
+        },
+        null,
+        2
+      )
+    );
+  }
+  /**
+   * Used to reset the static fields of the UniversalStore class when cleaning up tests
+   *
+   * @internal
+   */
+  static __reset() {
+    _UniversalStore.preparation.reject(new Error("reset")), _UniversalStore.setupPreparationPromise(), _UniversalStore.isInternalConstructing = !1;
+  }
+};
+/**
+ * Defines the possible actor types in the store system
+ *
+ * @readonly
+ */
+_UniversalStore.ActorType = {
+  LEADER: "LEADER",
+  FOLLOWER: "FOLLOWER"
+}, /**
+ * Defines the possible environments the store can run in
+ *
+ * @readonly
+ */
+_UniversalStore.Environment = {
+  SERVER: "SERVER",
+  MANAGER: "MANAGER",
+  PREVIEW: "PREVIEW",
+  UNKNOWN: "UNKNOWN",
+  MOCK: "MOCK"
+}, /**
+ * Internal event types used for store synchronization
+ *
+ * @readonly
+ */
+_UniversalStore.InternalEventType = {
+  EXISTING_STATE_REQUEST: "__EXISTING_STATE_REQUEST",
+  EXISTING_STATE_RESPONSE: "__EXISTING_STATE_RESPONSE",
+  SET_STATE: "__SET_STATE",
+  LEADER_CREATED: "__LEADER_CREATED",
+  FOLLOWER_CREATED: "__FOLLOWER_CREATED"
+}, _UniversalStore.Status = {
+  UNPREPARED: "UNPREPARED",
+  SYNCING: "SYNCING",
+  READY: "READY",
+  ERROR: "ERROR"
+}, // This is used to check if constructor was called from the static factory create()
+_UniversalStore.isInternalConstructing = !1, _UniversalStore.setupPreparationPromise();
+var UniversalStore = _UniversalStore;
+
+export {
+  UniversalStore
+};

package/dist/_browser-chunks/chunk-OVH3USFB.js

@@ -0,0 +1,20 @@
+// src/addon-pseudo-states/constants.ts
+var ADDON_ID = "@aussieljk/forkbook/pseudo-states", TOOL_ID = `${ADDON_ID}/tool`, PARAM_KEY = "pseudo", EXCLUDED_PSEUDO_ELEMENT_PATTERNS = ["::-(webkit|moz|ms)-[a-z-]+", "::part\\([^)]+\\)"], PSEUDO_STATES = {
+  hover: "hover",
+  active: "active",
+  focusVisible: "focus-visible",
+  focusWithin: "focus-within",
+  focus: "focus",
+  // must come after its alternatives
+  visited: "visited",
+  link: "link",
+  target: "target"
+};
+
+export {
+  ADDON_ID,
+  TOOL_ID,
+  PARAM_KEY,
+  EXCLUDED_PSEUDO_ELEMENT_PATTERNS,
+  PSEUDO_STATES
+};