@octanejs/base-ui 0.1.31 → 0.1.32

package/dist/cjs/utils/number/validate.cjs

@@ -0,0 +1,104 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validate_exports = {};
+__export(validate_exports, {
+  hasNumberFormatRoundingOptions: () => hasNumberFormatRoundingOptions,
+  removeFloatingPointErrors: () => removeFloatingPointErrors,
+  toValidatedNumber: () => toValidatedNumber
+});
+module.exports = __toCommonJS(validate_exports);
+var import_clamp = require("../clamp.cjs");
+var import_formatNumber = require("../formatNumber.cjs");
+var import_parse = require("./parse.cjs");
+const STEP_EPSILON_FACTOR = 1e-10;
+const MAX_FLOATING_POINT_CLEANUP_DELTA = 1e-10;
+function hasNumberFormatRoundingOptions(format) {
+  return format?.maximumFractionDigits != null || format?.minimumFractionDigits != null || format?.maximumSignificantDigits != null || format?.minimumSignificantDigits != null || format?.roundingIncrement != null || format?.roundingMode != null || format?.roundingPriority != null;
+}
+function removeFloatingPointErrors(value, format) {
+  if (!Number.isFinite(value)) {
+    return value;
+  }
+  if (!hasNumberFormatRoundingOptions(format)) {
+    const roundedValue2 = parseFloat(value.toPrecision(15));
+    const cleanupDelta = Math.abs(roundedValue2 - value);
+    const cleanupTolerance = Math.min(
+      Number.EPSILON * Math.max(1, Math.abs(value)),
+      MAX_FLOATING_POINT_CLEANUP_DELTA
+    );
+    return cleanupDelta <= cleanupTolerance ? roundedValue2 : value;
+  }
+  const formatter = (0, import_formatNumber.getFormatter)("en-US", {
+    ...format,
+    signDisplay: "auto",
+    currencySign: "standard",
+    notation: format.notation === "compact" ? "standard" : format.notation,
+    useGrouping: false
+  });
+  const roundedText = formatter.format(value);
+  const roundedValue = (0, import_parse.parseNumber)(roundedText, "en-US", format);
+  if (roundedValue === null) {
+    return value;
+  }
+  return formatter.format(roundedValue) === roundedText ? roundedValue : value;
+}
+function snapToStep(value, base, step, mode = "directional") {
+  const stepSize = Math.abs(step);
+  const direction = Math.sign(step);
+  const tolerance = stepSize * STEP_EPSILON_FACTOR * direction;
+  const rawSteps = value - base + tolerance;
+  if (mode === "nearest") {
+    return base + Math.round(rawSteps / step) * step;
+  }
+  const snappedSteps = direction > 0 ? Math.floor(rawSteps / stepSize) : Math.ceil(rawSteps / stepSize);
+  return base + snappedSteps * stepSize;
+}
+function toValidatedNumber(value, {
+  step,
+  minWithDefault,
+  maxWithDefault,
+  minWithZeroDefault,
+  format,
+  snapOnStep,
+  small,
+  clamp: shouldClamp
+}) {
+  if (value === null) {
+    return value;
+  }
+  let nextValue = value;
+  if (step != null && snapOnStep && step !== 0) {
+    const base = small || minWithDefault === Number.MIN_SAFE_INTEGER ? minWithZeroDefault : minWithDefault;
+    nextValue = snapToStep(nextValue, base, step, small ? "nearest" : "directional");
+  }
+  if (shouldClamp) {
+    nextValue = (0, import_clamp.clamp)(nextValue, minWithDefault, maxWithDefault);
+  }
+  if (step == null && !hasNumberFormatRoundingOptions(format)) {
+    return nextValue;
+  }
+  const roundedValue = removeFloatingPointErrors(nextValue, format);
+  return shouldClamp ? (0, import_clamp.clamp)(roundedValue, minWithDefault, maxWithDefault) : roundedValue;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hasNumberFormatRoundingOptions,
+  removeFloatingPointErrors,
+  toValidatedNumber
+});

package/dist/cjs/utils/owner.cjs

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var owner_exports = {};
+__export(owner_exports, {
+  ownerDocument: () => ownerDocument,
+  ownerWindow: () => ownerWindow
+});
+module.exports = __toCommonJS(owner_exports);
+function ownerWindow(node) {
+  return node?.ownerDocument?.defaultView ?? window;
+}
+function ownerDocument(node) {
+  return node?.ownerDocument || document;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ownerDocument,
+  ownerWindow
+});

package/dist/cjs/utils/platform.cjs

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var platform_exports = {};
+__export(platform_exports, {
+  platform: () => platform
+});
+module.exports = __toCommonJS(platform_exports);
+function ua() {
+  return typeof navigator === "undefined" ? "" : navigator.userAgent ?? "";
+}
+function isIOS() {
+  if (typeof navigator === "undefined") {
+    return false;
+  }
+  return /iP(ad|hone|od)/.test(navigator.platform ?? "");
+}
+function isWebKit() {
+  const s = ua();
+  return /AppleWebKit/.test(s) && !/Chrome|Chromium|Edg\//.test(s);
+}
+function isVoiceOver() {
+  return /Mac OS X|iPhone|iPad/.test(ua());
+}
+function isAndroid() {
+  return /Android/.test(ua());
+}
+function isMac() {
+  if (typeof navigator === "undefined") {
+    return false;
+  }
+  return /^Mac/.test(navigator.platform ?? "") && !isIOS();
+}
+function isJsdom() {
+  return /jsdom/i.test(ua());
+}
+const platform = {
+  os: {
+    get ios() {
+      return isIOS();
+    },
+    get android() {
+      return isAndroid();
+    },
+    get mac() {
+      return isMac();
+    }
+  },
+  engine: {
+    get webkit() {
+      return isWebKit();
+    }
+  },
+  env: {
+    get jsdom() {
+      return isJsdom();
+    }
+  },
+  screenReader: {
+    get voiceOver() {
+      return isVoiceOver();
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  platform
+});

package/dist/cjs/utils/popupStateMapping.cjs

@@ -0,0 +1,74 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var popupStateMapping_exports = {};
+__export(popupStateMapping_exports, {
+  CommonPopupDataAttributes: () => CommonPopupDataAttributes,
+  CommonTriggerDataAttributes: () => CommonTriggerDataAttributes,
+  popupStateMapping: () => popupStateMapping,
+  pressableTriggerOpenStateMapping: () => pressableTriggerOpenStateMapping,
+  triggerOpenStateMapping: () => triggerOpenStateMapping
+});
+module.exports = __toCommonJS(popupStateMapping_exports);
+const CommonPopupDataAttributes = {
+  open: "data-open",
+  closed: "data-closed",
+  startingStyle: "data-starting-style",
+  endingStyle: "data-ending-style",
+  anchorHidden: "data-anchor-hidden",
+  side: "data-side",
+  align: "data-align"
+};
+const CommonTriggerDataAttributes = {
+  popupOpen: "data-popup-open",
+  pressed: "data-pressed"
+};
+const TRIGGER_HOOK = { [CommonTriggerDataAttributes.popupOpen]: "" };
+const PRESSABLE_TRIGGER_HOOK = {
+  [CommonTriggerDataAttributes.popupOpen]: "",
+  [CommonTriggerDataAttributes.pressed]: ""
+};
+const POPUP_OPEN_HOOK = { [CommonPopupDataAttributes.open]: "" };
+const POPUP_CLOSED_HOOK = { [CommonPopupDataAttributes.closed]: "" };
+const ANCHOR_HIDDEN_HOOK = { [CommonPopupDataAttributes.anchorHidden]: "" };
+const triggerOpenStateMapping = {
+  open(value) {
+    return value ? TRIGGER_HOOK : null;
+  }
+};
+const pressableTriggerOpenStateMapping = {
+  open(value) {
+    return value ? PRESSABLE_TRIGGER_HOOK : null;
+  }
+};
+const popupStateMapping = {
+  open(value) {
+    return value ? POPUP_OPEN_HOOK : POPUP_CLOSED_HOOK;
+  },
+  anchorHidden(value) {
+    return value ? ANCHOR_HIDDEN_HOOK : null;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommonPopupDataAttributes,
+  CommonTriggerDataAttributes,
+  popupStateMapping,
+  pressableTriggerOpenStateMapping,
+  triggerOpenStateMapping
+});

package/dist/cjs/utils/popups/index.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var popups_exports = {};
+__export(popups_exports, {
+  createInlineMiddleware: () => import_inlineRect.createInlineMiddleware,
+  getInlineRectTriggerProps: () => import_inlineRect.getInlineRectTriggerProps,
+  updateInlineRectCoords: () => import_inlineRect.updateInlineRectCoords
+});
+module.exports = __toCommonJS(popups_exports);
+__reExport(popups_exports, require("./store.cjs"), module.exports);
+__reExport(popups_exports, require("./popupStoreUtils.cjs"), module.exports);
+__reExport(popups_exports, require("./popupTriggerMap.cjs"), module.exports);
+var import_inlineRect = require("./inlineRect.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createInlineMiddleware,
+  getInlineRectTriggerProps,
+  updateInlineRectCoords,
+  ...require("./store.cjs"),
+  ...require("./popupStoreUtils.cjs"),
+  ...require("./popupTriggerMap.cjs")
+});

package/dist/cjs/utils/popups/inlineRect.cjs

@@ -0,0 +1,218 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var inlineRect_exports = {};
+__export(inlineRect_exports, {
+  createInlineMiddleware: () => createInlineMiddleware,
+  getInlineRectTriggerProps: () => getInlineRectTriggerProps,
+  updateInlineRectCoords: () => updateInlineRectCoords
+});
+module.exports = __toCommonJS(inlineRect_exports);
+var import_dom = require("../dom.cjs");
+function createRect(left, top, right, bottom) {
+  return {
+    left,
+    top,
+    right,
+    bottom,
+    x: left,
+    y: top,
+    width: right - left,
+    height: bottom - top
+  };
+}
+function copyRect(rect) {
+  return {
+    left: rect.left,
+    top: rect.top,
+    right: rect.right,
+    bottom: rect.bottom,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function getLineRects(rects) {
+  const lines = [];
+  let previousRect;
+  let left = Number.POSITIVE_INFINITY;
+  let top = Number.POSITIVE_INFINITY;
+  let right = Number.NEGATIVE_INFINITY;
+  let bottom = Number.NEGATIVE_INFINITY;
+  for (const rect of Array.from(rects).sort((a, b) => a.top - b.top)) {
+    left = Math.min(left, rect.left);
+    top = Math.min(top, rect.top);
+    right = Math.max(right, rect.right);
+    bottom = Math.max(bottom, rect.bottom);
+    if (!previousRect || rect.top - previousRect.top > previousRect.height / 2) {
+      lines.push(copyRect(rect));
+    } else {
+      const line = lines[lines.length - 1];
+      line.left = Math.min(line.left, rect.left);
+      line.right = Math.max(line.right, rect.right);
+      line.bottom = Math.max(line.bottom, rect.bottom);
+      line.width = line.right - line.left;
+      line.height = line.bottom - line.top;
+    }
+    previousRect = rect;
+  }
+  return {
+    lines,
+    fallback: createRect(left, top, right, bottom)
+  };
+}
+function findLineIndex(lines, x, y) {
+  return lines.findIndex(
+    (lineRect) => x > lineRect.left - 2 && x < lineRect.right + 2 && y > lineRect.top - 2 && y < lineRect.bottom + 2
+  );
+}
+function createClientRect(rect) {
+  return createRect(rect.left, rect.top, rect.right, rect.bottom);
+}
+function getInlineRectCoords(element, clientX, clientY) {
+  const { lines } = getLineRects(element.getClientRects());
+  if (lines.length < 2) {
+    return void 0;
+  }
+  const lineIndex = findLineIndex(lines, clientX, clientY);
+  return {
+    x: clientX,
+    y: clientY,
+    lineIndex: lineIndex === -1 ? void 0 : lineIndex,
+    element
+  };
+}
+function getInlineReferenceRect(reference, placement, coords) {
+  const { lines, fallback } = getLineRects(reference.getClientRects());
+  if (lines.length < 2) {
+    return null;
+  }
+  const x = coords?.x;
+  const y = coords?.y;
+  const side = placement[0];
+  if (coords?.lineIndex != null && lines[coords.lineIndex]) {
+    return createClientRect(lines[coords.lineIndex]);
+  }
+  if (x != null && y != null) {
+    const lineIndex = findLineIndex(lines, x, y);
+    if (lineIndex !== -1) {
+      return createClientRect(lines[lineIndex]);
+    }
+  }
+  if (lines.length === 2 && lines[0].left > lines[1].right && x != null && y != null) {
+    return fallback;
+  }
+  if (side === "t" || side === "b") {
+    const firstRect = lines[0];
+    const lastRect = lines[lines.length - 1];
+    const targetRect = side === "t" ? firstRect : lastRect;
+    return createRect(targetRect.left, firstRect.top, targetRect.right, lastRect.bottom);
+  }
+  const isLeft = side === "l";
+  let left = lines[0].left;
+  let right = lines[0].right;
+  let edge = isLeft ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+  let targetFirstRect = lines[0];
+  let targetLastRect = lines[0];
+  for (const rect of lines) {
+    left = Math.min(left, rect.left);
+    right = Math.max(right, rect.right);
+    const nextEdge = isLeft ? rect.left : rect.right;
+    if (isLeft && nextEdge < edge || !isLeft && nextEdge > edge) {
+      edge = nextEdge;
+      targetFirstRect = rect;
+      targetLastRect = rect;
+    } else if (nextEdge === edge) {
+      targetLastRect = rect;
+    }
+  }
+  return createRect(left, targetFirstRect.top, right, targetLastRect.bottom);
+}
+function getContextElement(reference) {
+  if ("contextElement" in reference && reference.contextElement) {
+    return reference.contextElement;
+  }
+  return (0, import_dom.isElement)(reference) ? reference : void 0;
+}
+function getInlineRectTriggerProps(coordsRef, isOpen) {
+  function updateCoords(event) {
+    updateInlineRectCoords(coordsRef, event.currentTarget, event.clientX, event.clientY);
+  }
+  function updateCoordsIfClosed(event) {
+    if (!isOpen) {
+      updateCoords(event);
+    }
+  }
+  return {
+    onFocus() {
+      coordsRef.current = void 0;
+    },
+    onMouseEnter: updateCoordsIfClosed,
+    onMouseMove: updateCoordsIfClosed
+  };
+}
+function updateInlineRectCoords(coordsRef, element, clientX, clientY) {
+  const nextCoords = getInlineRectCoords(element, clientX, clientY);
+  coordsRef.current = nextCoords;
+  return nextCoords;
+}
+function createInlineMiddleware(coordsRef) {
+  return {
+    name: "inline",
+    async fn(state) {
+      const reference = state.elements.reference;
+      if (typeof reference?.getClientRects !== "function") {
+        return {};
+      }
+      const contextElement = getContextElement(reference);
+      const coords = coordsRef.current;
+      const currentCoords = coords?.element === reference || coords?.element === contextElement ? coords : void 0;
+      const rect = getInlineReferenceRect(
+        reference,
+        state.placement,
+        currentCoords
+      );
+      if (!rect || typeof state.platform.getElementRects !== "function") {
+        return {};
+      }
+      const resetRects = await state.platform.getElementRects({
+        reference: {
+          contextElement,
+          getBoundingClientRect() {
+            return rect;
+          }
+        },
+        floating: state.elements.floating,
+        strategy: state.strategy
+      });
+      if (state.rects.reference.x === resetRects.reference.x && state.rects.reference.y === resetRects.reference.y && state.rects.reference.width === resetRects.reference.width && state.rects.reference.height === resetRects.reference.height) {
+        return {};
+      }
+      return {
+        reset: {
+          rects: resetRects
+        }
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createInlineMiddleware,
+  getInlineRectTriggerProps,
+  updateInlineRectCoords
+});