@aussieljk/forkbook 0.0.0-stage → 0.0.1-10

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

@@ -0,0 +1,502 @@
+import {
+  ARROW_DOWN,
+  ARROW_LEFT,
+  ARROW_RIGHT,
+  ARROW_UP,
+  COMPOSITE_KEYS,
+  CompositeRootContext,
+  EMPTY_ARRAY,
+  EMPTY_OBJECT,
+  END,
+  HOME,
+  MODIFIER_KEYS,
+  error,
+  findNonDisabledListIndex,
+  getMaxListIndex,
+  getMinListIndex,
+  getTarget,
+  isIndexOutOfListBounds,
+  isListIndexDisabled,
+  isNativeInput,
+  scrollIntoViewIfNeeded,
+  useCompositeRootContext,
+  useDirection,
+  useIsoLayoutEffect,
+  useMergedRefs,
+  useRefWithInit,
+  useRenderElement,
+  useStableCallback
+} from "./chunk-XTQCLWVH.js";
+
+// ../../node_modules/@base-ui/utils/useControlled.mjs
+import * as React from "react";
+function useControlled({
+  controlled,
+  default: defaultProp,
+  name,
+  state = "value"
+}) {
+  let {
+    current: isControlled
+  } = React.useRef(controlled !== void 0), [valueState, setValue] = React.useState(() => defaultProp), value = isControlled && controlled !== void 0 ? controlled : valueState;
+  if (process.env.NODE_ENV !== "production") {
+    React.useEffect(() => {
+      isControlled !== (controlled !== void 0) && error([`A component is changing the ${isControlled ? "" : "un"}controlled ${state} state of ${name} to be ${isControlled ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${name} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join(`
+`));
+    }, [state, name, controlled]);
+    let {
+      current: defaultValue
+    } = React.useRef(defaultProp);
+    React.useEffect(() => {
+      !isControlled && serializeToDevModeString(defaultValue) !== serializeToDevModeString(defaultProp) && error([`A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. To suppress this warning opt to use a controlled ${name}.`].join(`
+`));
+    }, [defaultProp]);
+  }
+  let setValueIfUncontrolled = React.useCallback((newValue) => {
+    isControlled || setValue(newValue);
+  }, []);
+  return [value, setValueIfUncontrolled];
+}
+function serializeToDevModeString(input) {
+  let nextId = 0, seen = /* @__PURE__ */ new WeakMap();
+  try {
+    return JSON.stringify(input, function(key, value) {
+      if (!(key === "_owner" && this != null && typeof this == "object" && "$$typeof" in this)) {
+        if (typeof value == "bigint")
+          return `__bigint__:${value}`;
+        if (value !== null && typeof value == "object") {
+          let id = seen.get(value);
+          if (id !== void 0)
+            return `__object__:${id}`;
+          seen.set(value, nextId), nextId += 1;
+        }
+        return value;
+      }
+    }) ?? `__top__:${typeof input}`;
+  } catch {
+    return "__unserializable__";
+  }
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/list/useCompositeListItem.mjs
+import * as React3 from "react";
+
+// ../../node_modules/@base-ui/react/internals/composite/list/CompositeListContext.mjs
+import * as React2 from "react";
+var CompositeListContext = React2.createContext({
+  register: () => {
+  },
+  unregister: () => {
+  },
+  subscribeMapChange: () => () => {
+  },
+  nextIndexRef: {
+    current: 0
+  }
+});
+process.env.NODE_ENV !== "production" && (CompositeListContext.displayName = "CompositeListContext");
+function useCompositeListContext() {
+  return React2.useContext(CompositeListContext);
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/list/useCompositeListItem.mjs
+function useCompositeListItem(params = {}) {
+  let {
+    guess,
+    label,
+    metadata,
+    textRef,
+    index: externalIndex
+  } = params, {
+    register,
+    unregister,
+    subscribeMapChange,
+    nextIndexRef
+  } = useCompositeListContext(), indexRef = React3.useRef(-1), [internalIndex, setInternalIndex] = React3.useState(externalIndex == null && guess ? () => {
+    if (indexRef.current === -1) {
+      let newIndex = nextIndexRef.current;
+      nextIndexRef.current += 1, indexRef.current = newIndex;
+    }
+    return indexRef.current;
+  } : -1), index = externalIndex ?? internalIndex, componentRef = React3.useRef(null), ref = React3.useCallback((node) => {
+    let previousNode = componentRef.current;
+    previousNode && unregister(previousNode), componentRef.current = node, node && register(node, {
+      metadata: metadata ?? null,
+      index: externalIndex ?? null,
+      label,
+      textRef
+    });
+  }, [externalIndex, register, unregister, metadata, label, textRef]);
+  return useIsoLayoutEffect(() => {
+    if (externalIndex == null)
+      return subscribeMapChange((map) => {
+        let i = componentRef.current ? map.get(componentRef.current)?.index : null;
+        i != null && setInternalIndex(i);
+      });
+  }, [externalIndex, subscribeMapChange]), {
+    ref,
+    index
+  };
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/item/useCompositeItem.mjs
+import * as React4 from "react";
+function useCompositeItem(params = {}) {
+  let {
+    highlightItemOnHover,
+    highlightedIndex,
+    onHighlightedIndexChange
+  } = useCompositeRootContext(), {
+    ref,
+    index
+  } = useCompositeListItem(params), isHighlighted = highlightedIndex === index, itemRef = React4.useRef(null), mergedRef = useMergedRefs(ref, itemRef);
+  return {
+    compositeProps: {
+      tabIndex: isHighlighted ? 0 : -1,
+      onFocus() {
+        onHighlightedIndexChange(index);
+      },
+      onMouseMove() {
+        let item = itemRef.current;
+        if (!highlightItemOnHover || !item)
+          return;
+        let disabled = item.hasAttribute("disabled") || item.ariaDisabled === "true";
+        !isHighlighted && !disabled && item.focus();
+      }
+    },
+    compositeRef: mergedRef,
+    index
+  };
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/list/CompositeList.mjs
+import * as React5 from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
+function CompositeList(props) {
+  let {
+    children,
+    elementsRef,
+    labelsRef,
+    onMapChange: onMapChangeProp
+  } = props, onMapChange = useStableCallback(onMapChangeProp), [, setMapTick] = React5.useState(0), listeners = useRefWithInit(createListeners).current, map = useRefWithInit(createMap).current, nextIndexRef = React5.useRef(0), isDirtyRef = React5.useRef(!0), itemsRef = React5.useRef(null), mutationObserverRef = React5.useRef(null), scheduleMapUpdate = useStableCallback(() => {
+    isDirtyRef.current || (isDirtyRef.current = !0, setMapTick((tick) => tick + 1));
+  }), register = useStableCallback((node, registration) => {
+    map.set(node, registration), scheduleMapUpdate();
+  }), unregister = useStableCallback((node) => {
+    map.delete(node), scheduleMapUpdate();
+  }), syncRefs = useStableCallback((items) => {
+    let nextMap = /* @__PURE__ */ new Map();
+    return elementsRef.current.length = 0, labelsRef && (labelsRef.current.length = 0), items.forEach((item) => {
+      nextMap.set(item.element, {
+        ...item.registration.metadata ?? {},
+        index: item.index
+      }), elementsRef.current[item.index] = item.element, labelsRef && (labelsRef.current[item.index] = item.registration.label !== void 0 ? item.registration.label : item.registration.textRef?.current?.textContent ?? item.element.textContent);
+    }), nextIndexRef.current = elementsRef.current.length, nextMap;
+  });
+  function observe(sortedNodes) {
+    if (mutationObserverRef.current?.disconnect(), mutationObserverRef.current = null, typeof MutationObserver != "function" || sortedNodes.length < 2)
+      return;
+    let mutationObserver = new MutationObserver((entries) => {
+      if (!hasMovedNode(entries))
+        return;
+      let previousConnectedNode = null;
+      for (let node of sortedNodes)
+        if (node.isConnected) {
+          if (previousConnectedNode && sortByDocumentPosition(previousConnectedNode, node) > 0) {
+            mutationObserver.disconnect(), scheduleMapUpdate();
+            return;
+          }
+          previousConnectedNode = node;
+        }
+    });
+    mutationObserverRef.current = mutationObserver;
+    let roots = /* @__PURE__ */ new Set();
+    for (let i = 1; i < sortedNodes.length; i += 1) {
+      let root = getCommonAncestor(sortedNodes[i - 1], sortedNodes[i]);
+      root && roots.add(root);
+    }
+    roots.forEach((root) => mutationObserver.observe(root, {
+      childList: !0
+    }));
+  }
+  let flush = useStableCallback(() => {
+    let [items, automaticNodes] = getCompositeListSnapshot(map), nextMap = syncRefs(items), previousItems = itemsRef.current, changed = !previousItems || previousItems.length !== items.length || items.some((item, index) => {
+      let previousItem = previousItems[index];
+      return item.index !== previousItem.index || item.element !== previousItem.element || item.registration.index !== previousItem.registration.index || item.registration.metadata !== previousItem.registration.metadata;
+    });
+    observe(automaticNodes), itemsRef.current = items, isDirtyRef.current = !1, changed && (listeners.forEach((listener) => listener(nextMap)), onMapChange(nextMap));
+  });
+  useIsoLayoutEffect(() => (!isDirtyRef.current && itemsRef.current && syncRefs(itemsRef.current), () => {
+    elementsRef.current = [], labelsRef && (labelsRef.current = []);
+  }), [elementsRef, labelsRef, syncRefs]), useIsoLayoutEffect(() => {
+    isDirtyRef.current && flush();
+  }), useIsoLayoutEffect(() => () => {
+    mutationObserverRef.current?.disconnect(), isDirtyRef.current = !0;
+  }, []);
+  let subscribeMapChange = useStableCallback((fn) => (listeners.add(fn), () => {
+    listeners.delete(fn);
+  })), contextValue = React5.useMemo(() => ({
+    register,
+    unregister,
+    subscribeMapChange,
+    nextIndexRef
+  }), [register, unregister, subscribeMapChange, nextIndexRef]);
+  return _jsx(CompositeListContext.Provider, {
+    value: contextValue,
+    children
+  });
+}
+function createMap() {
+  return /* @__PURE__ */ new Map();
+}
+function createListeners() {
+  return /* @__PURE__ */ new Set();
+}
+function getCompositeListSnapshot(map) {
+  let reservedIndices = /* @__PURE__ */ new Set(), items = [], automaticItems = [];
+  map.forEach((registration, node) => {
+    if (!node.isConnected)
+      return;
+    let index = registration.index, item = {
+      index: index ?? -1,
+      element: node,
+      registration
+    };
+    index === null ? automaticItems.push(item) : index >= 0 && (reservedIndices.add(index), items.push(item));
+  });
+  let nextAutomaticIndex = 0;
+  return automaticItems.sort((a, b) => sortByDocumentPosition(a.element, b.element)), automaticItems.forEach((item) => {
+    for (; reservedIndices.has(nextAutomaticIndex); )
+      nextAutomaticIndex += 1;
+    item.index = nextAutomaticIndex, items.push(item), nextAutomaticIndex += 1;
+  }), reservedIndices.size > 0 && items.sort((a, b) => a.index - b.index), [items, automaticItems.map((item) => item.element)];
+}
+function getCommonAncestor(firstNode, lastNode) {
+  let ancestor = firstNode.parentElement;
+  for (; ancestor && !ancestor.contains(lastNode); )
+    ancestor = ancestor.parentElement;
+  return ancestor;
+}
+function hasMovedNode(entries) {
+  for (let entry of entries)
+    for (let i = 0; i < entry.removedNodes.length; i += 1)
+      if (entry.removedNodes[i].isConnected)
+        return !0;
+  return !1;
+}
+function sortByDocumentPosition(a, b) {
+  return a.nextElementSibling === b ? -1 : b.nextElementSibling === a ? 1 : a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/constants.mjs
+var ACTIVE_COMPOSITE_ITEM = "data-composite-item-active";
+
+// ../../node_modules/@base-ui/react/internals/composite/root/CompositeRoot.mjs
+import * as React7 from "react";
+
+// ../../node_modules/@base-ui/react/internals/composite/root/useCompositeRoot.mjs
+import * as React6 from "react";
+
+// ../../node_modules/@base-ui/utils/isElementDisabled.mjs
+function isElementDisabled(element) {
+  return element == null || element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true";
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/root/useCompositeRoot.mjs
+function useCompositeRoot(params) {
+  let {
+    loopFocus = !0,
+    orientation = "both",
+    grid,
+    onLoop,
+    direction,
+    highlightedIndex: externalHighlightedIndex,
+    onHighlightedIndexChange: externalSetHighlightedIndex,
+    rootRef: externalRef,
+    enableHomeAndEndKeys = !1,
+    stopEventPropagation,
+    disabledIndices,
+    modifierKeys = EMPTY_ARRAY
+  } = params, [internalHighlightedIndex, internalSetHighlightedIndex] = React6.useState(0), isGrid = grid != null, rootRef = React6.useRef(null), mergedRef = useMergedRefs(rootRef, externalRef), elementsRef = React6.useRef([]), hasSetDefaultIndexRef = React6.useRef(!1), highlightedElementRef = React6.useRef(null), highlightedIndex = externalHighlightedIndex ?? internalHighlightedIndex, onHighlightedIndexChange = useStableCallback((index, shouldScrollIntoView = !1) => {
+    if (highlightedElementRef.current = elementsRef.current[index] ?? null, (externalSetHighlightedIndex ?? internalSetHighlightedIndex)(index), shouldScrollIntoView) {
+      let newActiveItem = elementsRef.current[index];
+      scrollIntoViewIfNeeded(rootRef.current, newActiveItem, direction, orientation);
+    }
+  }), onMapChange = useStableCallback((map) => {
+    if (map.size === 0)
+      return;
+    if (hasSetDefaultIndexRef.current) {
+      let elements = elementsRef.current, nextIndex = elements.indexOf(highlightedElementRef.current);
+      if (nextIndex === -1) {
+        let replacement = elements[highlightedIndex];
+        !replacement || isListIndexDisabled(elements, highlightedIndex, disabledIndices) ? onHighlightedIndexChange(getFallbackIndex(elements, disabledIndices)) : highlightedElementRef.current = replacement;
+      } else nextIndex !== highlightedIndex && onHighlightedIndexChange(nextIndex);
+      return;
+    }
+    hasSetDefaultIndexRef.current = !0;
+    let sortedElements = Array.from(map.keys()), activeItem = sortedElements.find((compositeElement) => compositeElement?.hasAttribute(ACTIVE_COMPOSITE_ITEM)) ?? null, activeIndex = activeItem ? map.get(activeItem)?.index ?? -1 : -1;
+    if (activeIndex !== -1)
+      onHighlightedIndexChange(activeIndex);
+    else if (isListIndexDisabled(sortedElements, highlightedIndex, disabledIndices)) {
+      let firstEnabledIndex = findNonDisabledListIndex(sortedElements, {
+        disabledIndices
+      });
+      isIndexOutOfListBounds(sortedElements, firstEnabledIndex) || onHighlightedIndexChange(firstEnabledIndex);
+    }
+    scrollIntoViewIfNeeded(rootRef.current, activeItem, direction, orientation);
+  });
+  useIsoLayoutEffect(() => {
+    if (disabledIndices == null || externalHighlightedIndex != null || !hasSetDefaultIndexRef.current)
+      return;
+    let elements = elementsRef.current;
+    if (isListIndexDisabled(elements, highlightedIndex, disabledIndices)) {
+      let firstEnabledIndex = findNonDisabledListIndex(elements, {
+        disabledIndices
+      });
+      isIndexOutOfListBounds(elements, firstEnabledIndex) || onHighlightedIndexChange(firstEnabledIndex);
+    }
+  }, [disabledIndices, externalHighlightedIndex, highlightedIndex, elementsRef, onHighlightedIndexChange]);
+  let wrappedOnLoop = useStableCallback((event, prevIndex, nextIndex) => onLoop ? onLoop(event, prevIndex, nextIndex, elementsRef) : nextIndex), onKeyDown = useStableCallback((event) => {
+    let isHomeOrEnd = event.key === HOME || event.key === END;
+    if (!COMPOSITE_KEYS.has(event.key) || !enableHomeAndEndKeys && isHomeOrEnd || isModifierKeySet(event, modifierKeys) || !rootRef.current)
+      return;
+    let isRtl = direction === "rtl", horizontalForwardKey = isRtl ? ARROW_LEFT : ARROW_RIGHT, horizontalBackwardKey = isRtl ? ARROW_RIGHT : ARROW_LEFT, forwardKey = orientation === "vertical" ? ARROW_DOWN : horizontalForwardKey, backwardKey = orientation === "vertical" ? ARROW_UP : horizontalBackwardKey, target = getTarget(event.nativeEvent);
+    if (target != null && isNativeInput(target) && !isElementDisabled(target)) {
+      let selectionStart = target.selectionStart, selectionEnd = target.selectionEnd, textContent = target.value;
+      if (selectionStart == null || event.shiftKey || selectionStart !== selectionEnd || event.key !== backwardKey && selectionStart < textContent.length || event.key !== forwardKey && selectionStart > 0)
+        return;
+    }
+    let nextIndex = highlightedIndex, minIndex = getMinListIndex(elementsRef, disabledIndices), maxIndex = getMaxListIndex(elementsRef, disabledIndices);
+    grid != null && (nextIndex = grid({
+      disabledIndices,
+      elementsRef,
+      event,
+      highlightedIndex,
+      loopFocus,
+      maxIndex,
+      minIndex,
+      onLoop: wrappedOnLoop,
+      orientation,
+      rtl: isRtl
+    }));
+    let isForwardKey = orientation !== "vertical" && event.key === horizontalForwardKey || orientation !== "horizontal" && event.key === ARROW_DOWN, isBackwardKey = orientation !== "vertical" && event.key === horizontalBackwardKey || orientation !== "horizontal" && event.key === ARROW_UP;
+    enableHomeAndEndKeys && (event.key === HOME ? nextIndex = minIndex : event.key === END && (nextIndex = maxIndex)), nextIndex === highlightedIndex && (isForwardKey || isBackwardKey) && (loopFocus && nextIndex === maxIndex && isForwardKey ? (nextIndex = minIndex, onLoop && (nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef))) : loopFocus && nextIndex === minIndex && isBackwardKey ? (nextIndex = maxIndex, onLoop && (nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef))) : nextIndex = findNonDisabledListIndex(elementsRef.current, {
+      startingIndex: nextIndex,
+      decrement: isBackwardKey,
+      disabledIndices
+    })), nextIndex !== highlightedIndex && !isIndexOutOfListBounds(elementsRef.current, nextIndex) && (stopEventPropagation && event.stopPropagation(), (isGrid || isHomeOrEnd || isForwardKey || isBackwardKey) && event.preventDefault(), onHighlightedIndexChange(nextIndex, !0), queueMicrotask(() => {
+      elementsRef.current[nextIndex]?.focus();
+    }));
+  });
+  return {
+    props: {
+      ref: mergedRef,
+      onFocus(event) {
+        let element = rootRef.current, target = getTarget(event.nativeEvent);
+        !element || target == null || !isNativeInput(target) || target.setSelectionRange(0, target.value.length);
+      },
+      onKeyDown
+    },
+    highlightedIndex,
+    onHighlightedIndexChange,
+    elementsRef,
+    onMapChange,
+    relayKeyboardEvent: onKeyDown
+  };
+}
+function getFallbackIndex(elements, disabledIndices) {
+  let fallbackIndex = -1;
+  for (let index = 0; index < elements.length; index += 1) {
+    let element = elements[index];
+    if (!(!element || isListIndexDisabled(elements, index, disabledIndices))) {
+      if (element.hasAttribute(ACTIVE_COMPOSITE_ITEM))
+        return index;
+      fallbackIndex === -1 && (fallbackIndex = index);
+    }
+  }
+  return Math.max(fallbackIndex, 0);
+}
+function isModifierKeySet(event, ignoredModifierKeys) {
+  for (let key of MODIFIER_KEYS)
+    if (!ignoredModifierKeys.includes(key) && event.getModifierState(key))
+      return !0;
+  return !1;
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/root/CompositeRoot.mjs
+import { jsx as _jsx2 } from "react/jsx-runtime";
+function CompositeRoot(componentProps) {
+  let {
+    render,
+    className,
+    style,
+    refs = EMPTY_ARRAY,
+    props = EMPTY_ARRAY,
+    state = EMPTY_OBJECT,
+    stateAttributesMapping,
+    highlightedIndex: highlightedIndexProp,
+    onHighlightedIndexChange: onHighlightedIndexChangeProp,
+    orientation,
+    grid,
+    loopFocus,
+    onLoop,
+    enableHomeAndEndKeys,
+    onMapChange: onMapChangeProp,
+    stopEventPropagation = !0,
+    rootRef,
+    disabledIndices,
+    modifierKeys,
+    highlightItemOnHover = !1,
+    tag = "div",
+    ...elementProps
+  } = componentProps, direction = useDirection(), {
+    props: defaultProps,
+    highlightedIndex,
+    onHighlightedIndexChange,
+    elementsRef,
+    onMapChange: onMapChangeUnwrapped,
+    relayKeyboardEvent
+  } = useCompositeRoot({
+    grid,
+    loopFocus,
+    onLoop,
+    orientation,
+    highlightedIndex: highlightedIndexProp,
+    onHighlightedIndexChange: onHighlightedIndexChangeProp,
+    rootRef,
+    stopEventPropagation,
+    enableHomeAndEndKeys,
+    direction,
+    disabledIndices,
+    modifierKeys
+  }), element = useRenderElement(tag, componentProps, {
+    state,
+    ref: refs,
+    props: [defaultProps, ...props, elementProps],
+    stateAttributesMapping
+  }), contextValue = React7.useMemo(() => ({
+    highlightedIndex,
+    onHighlightedIndexChange,
+    highlightItemOnHover,
+    relayKeyboardEvent
+  }), [highlightedIndex, onHighlightedIndexChange, highlightItemOnHover, relayKeyboardEvent]);
+  return _jsx2(CompositeRootContext.Provider, {
+    value: contextValue,
+    children: _jsx2(CompositeList, {
+      elementsRef,
+      onMapChange: (newMap) => {
+        onMapChangeProp?.(newMap), onMapChangeUnwrapped(newMap);
+      },
+      children: element
+    })
+  });
+}
+
+export {
+  useControlled,
+  useCompositeListItem,
+  useCompositeItem,
+  CompositeList,
+  ACTIVE_COMPOSITE_ITEM,
+  CompositeRoot
+};

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
+};

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

@@ -0,0 +1,14 @@
+// src/addon-a11y/constants.ts
+var ADDON_ID = "@aussieljk/forkbook/a11y", PANEL_ID = `${ADDON_ID}/panel`, PARAM_KEY = "a11y", VISION_GLOBAL_KEY = "vision", UI_STATE_ID = `${ADDON_ID}/ui`, RESULT = `${ADDON_ID}/result`, REQUEST = `${ADDON_ID}/request`, RUNNING = `${ADDON_ID}/running`, ERROR = `${ADDON_ID}/error`, MANUAL = `${ADDON_ID}/manual`, DOCUMENTATION_LINK = "writing-tests/accessibility-testing", DOCUMENTATION_DISCREPANCY_LINK = `${DOCUMENTATION_LINK}#why-are-my-tests-failing-in-different-environments`;
+var EVENTS = { RESULT, REQUEST, RUNNING, ERROR, MANUAL }, STATUS_TYPE_ID_COMPONENT_TEST = "@aussieljk/forkbook/component-test", STATUS_TYPE_ID_A11Y = "@aussieljk/forkbook/a11y";
+
+export {
+  ADDON_ID,
+  PANEL_ID,
+  PARAM_KEY,
+  VISION_GLOBAL_KEY,
+  DOCUMENTATION_DISCREPANCY_LINK,
+  EVENTS,
+  STATUS_TYPE_ID_COMPONENT_TEST,
+  STATUS_TYPE_ID_A11Y
+};

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

@@ -0,0 +1,13 @@
+// src/addon-docs/blocks/controls/helpers.ts
+var getControlId = (value, storyId, controlsId) => {
+  let base = value.replace(/\s+/g, "-"), parts = ["control"];
+  return controlsId && parts.push(controlsId), storyId && parts.push(storyId), parts.push(base), parts.join("-");
+}, getControlSetterButtonId = (value, storyId, controlsId) => {
+  let base = value.replace(/\s+/g, "-"), parts = ["set"];
+  return controlsId && parts.push(controlsId), storyId && parts.push(storyId), parts.push(base), parts.join("-");
+};
+
+export {
+  getControlId,
+  getControlSetterButtonId
+};

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

@@ -0,0 +1,21 @@
+// src/shared/story-grid.ts
+var isGridEntry = (entry, hiddenImportPath) => entry.importPath !== hiddenImportPath && (entry.type === "docs" || entry.type === "story" && entry.subtype !== "test"), groupEntriesByComponent = (entries, { hiddenImportPath } = {}) => {
+  let byTitle = /* @__PURE__ */ new Map();
+  for (let entry of entries) {
+    if (!isGridEntry(entry, hiddenImportPath))
+      continue;
+    let component = byTitle.get(entry.title);
+    component || (component = {
+      title: entry.title,
+      name: entry.title.split("/").pop() ?? entry.title,
+      entryId: entry.id,
+      viewMode: entry.type,
+      storyIds: []
+    }, byTitle.set(entry.title, component)), entry.type === "docs" && component.viewMode !== "docs" && (component.entryId = entry.id, component.viewMode = "docs"), entry.type === "story" ? (component.storyIds.push(entry.id), component.firstStoryId || (component.firstStoryId = entry.id, component.thumbnail = entry.thumbnail ?? component.thumbnail)) : component.thumbnail ??= entry.thumbnail;
+  }
+  return [...byTitle.values()];
+};
+
+export {
+  groupEntriesByComponent
+};

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

@@ -0,0 +1,41 @@
+// src/shared/open-service/query-state.ts
+function buildQueryState(data, lifecycle) {
+  let isPending = lifecycle.status === "pending", isLoading = lifecycle.loadStatus === "loading";
+  return {
+    data,
+    error: lifecycle.error,
+    status: lifecycle.status,
+    loadStatus: lifecycle.loadStatus,
+    isPending,
+    isSuccess: lifecycle.status === "success",
+    isError: lifecycle.status === "error",
+    isLoading,
+    isInitialLoading: isPending && isLoading && data === void 0,
+    isRefreshing: isLoading && !isPending
+  };
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function seedQueryState(query, input, selector) {
+  try {
+    let output = query.get(input);
+    return buildQueryState(selector ? selector(output) : output, {
+      status: "pending",
+      error: void 0,
+      loadStatus: "loading"
+    });
+  } catch (error) {
+    return buildQueryState(void 0, {
+      status: "error",
+      error: toError(error),
+      loadStatus: "idle"
+    });
+  }
+}
+
+export {
+  buildQueryState,
+  toError,
+  seedQueryState
+};