@veritone-ce/design-system 2.8.14-next.2.0 → 2.8.14

package/dist/cjs/bundled_modules/@react-spring/web/dist/react-spring_web.modern.js

@@ -0,0 +1,382 @@
+'use strict';
+
+var reactSpring_core_modern = require('../../core/dist/react-spring_core.modern.js');
+var reactDom = require('react-dom');
+var reactSpring_shared_modern = require('../../shared/dist/react-spring_shared.modern.js');
+var reactSpring_animated_modern = require('../../animated/dist/react-spring_animated.modern.js');
+
+// src/index.ts
+
+// src/applyAnimatedValues.ts
+var isCustomPropRE = /^--/;
+function dangerousStyleValue(name, value) {
+  if (value == null || typeof value === "boolean" || value === "") return "";
+  if (typeof value === "number" && value !== 0 && !isCustomPropRE.test(name) && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name]))
+    return value + "px";
+  return ("" + value).trim();
+}
+var attributeCache = {};
+function applyAnimatedValues(instance, props) {
+  if (!instance.nodeType || !instance.setAttribute) {
+    return false;
+  }
+  const isFilterElement = instance.nodeName === "filter" || instance.parentNode && instance.parentNode.nodeName === "filter";
+  const {
+    className,
+    style,
+    children,
+    scrollTop,
+    scrollLeft,
+    viewBox,
+    ...attributes
+  } = props;
+  const values = Object.values(attributes);
+  const names = Object.keys(attributes).map(
+    (name) => isFilterElement || instance.hasAttribute(name) ? name : attributeCache[name] || (attributeCache[name] = name.replace(
+      /([A-Z])/g,
+      // Attributes are written in dash case
+      (n) => "-" + n.toLowerCase()
+    ))
+  );
+  if (children !== void 0) {
+    instance.textContent = children;
+  }
+  for (const name in style) {
+    if (style.hasOwnProperty(name)) {
+      const value = dangerousStyleValue(name, style[name]);
+      if (isCustomPropRE.test(name)) {
+        instance.style.setProperty(name, value);
+      } else {
+        instance.style[name] = value;
+      }
+    }
+  }
+  names.forEach((name, i) => {
+    instance.setAttribute(name, values[i]);
+  });
+  if (className !== void 0) {
+    instance.className = className;
+  }
+  if (scrollTop !== void 0) {
+    instance.scrollTop = scrollTop;
+  }
+  if (scrollLeft !== void 0) {
+    instance.scrollLeft = scrollLeft;
+  }
+  if (viewBox !== void 0) {
+    instance.setAttribute("viewBox", viewBox);
+  }
+}
+var isUnitlessNumber = {
+  animationIterationCount: true,
+  borderImageOutset: true,
+  borderImageSlice: true,
+  borderImageWidth: true,
+  boxFlex: true,
+  boxFlexGroup: true,
+  boxOrdinalGroup: true,
+  columnCount: true,
+  columns: true,
+  flex: true,
+  flexGrow: true,
+  flexPositive: true,
+  flexShrink: true,
+  flexNegative: true,
+  flexOrder: true,
+  gridRow: true,
+  gridRowEnd: true,
+  gridRowSpan: true,
+  gridRowStart: true,
+  gridColumn: true,
+  gridColumnEnd: true,
+  gridColumnSpan: true,
+  gridColumnStart: true,
+  fontWeight: true,
+  lineClamp: true,
+  lineHeight: true,
+  opacity: true,
+  order: true,
+  orphans: true,
+  tabSize: true,
+  widows: true,
+  zIndex: true,
+  zoom: true,
+  // SVG-related properties
+  fillOpacity: true,
+  floodOpacity: true,
+  stopOpacity: true,
+  strokeDasharray: true,
+  strokeDashoffset: true,
+  strokeMiterlimit: true,
+  strokeOpacity: true,
+  strokeWidth: true
+};
+var prefixKey = (prefix, key) => prefix + key.charAt(0).toUpperCase() + key.substring(1);
+var prefixes = ["Webkit", "Ms", "Moz", "O"];
+isUnitlessNumber = Object.keys(isUnitlessNumber).reduce((acc, prop) => {
+  prefixes.forEach((prefix) => acc[prefixKey(prefix, prop)] = acc[prop]);
+  return acc;
+}, isUnitlessNumber);
+var domTransforms = /^(matrix|translate|scale|rotate|skew)/;
+var pxTransforms = /^(translate)/;
+var degTransforms = /^(rotate|skew)/;
+var addUnit = (value, unit) => reactSpring_shared_modern.is.num(value) && value !== 0 ? value + unit : value;
+var isValueIdentity = (value, id) => reactSpring_shared_modern.is.arr(value) ? value.every((v) => isValueIdentity(v, id)) : reactSpring_shared_modern.is.num(value) ? value === id : parseFloat(value) === id;
+var AnimatedStyle = class extends reactSpring_animated_modern.AnimatedObject {
+  constructor({ x, y, z, ...style }) {
+    const inputs = [];
+    const transforms = [];
+    if (x || y || z) {
+      inputs.push([x || 0, y || 0, z || 0]);
+      transforms.push((xyz) => [
+        `translate3d(${xyz.map((v) => addUnit(v, "px")).join(",")})`,
+        // prettier-ignore
+        isValueIdentity(xyz, 0)
+      ]);
+    }
+    reactSpring_shared_modern.eachProp(style, (value, key) => {
+      if (key === "transform") {
+        inputs.push([value || ""]);
+        transforms.push((transform) => [transform, transform === ""]);
+      } else if (domTransforms.test(key)) {
+        delete style[key];
+        if (reactSpring_shared_modern.is.und(value)) return;
+        const unit = pxTransforms.test(key) ? "px" : degTransforms.test(key) ? "deg" : "";
+        inputs.push(reactSpring_shared_modern.toArray(value));
+        transforms.push(
+          key === "rotate3d" ? ([x2, y2, z2, deg]) => [
+            `rotate3d(${x2},${y2},${z2},${addUnit(deg, unit)})`,
+            isValueIdentity(deg, 0)
+          ] : (input) => [
+            `${key}(${input.map((v) => addUnit(v, unit)).join(",")})`,
+            isValueIdentity(input, key.startsWith("scale") ? 1 : 0)
+          ]
+        );
+      }
+    });
+    if (inputs.length) {
+      style.transform = new FluidTransform(inputs, transforms);
+    }
+    super(style);
+  }
+};
+var FluidTransform = class extends reactSpring_shared_modern.FluidValue {
+  constructor(inputs, transforms) {
+    super();
+    this.inputs = inputs;
+    this.transforms = transforms;
+    this._value = null;
+  }
+  get() {
+    return this._value || (this._value = this._get());
+  }
+  _get() {
+    let transform = "";
+    let identity = true;
+    reactSpring_shared_modern.each(this.inputs, (input, i) => {
+      const arg1 = reactSpring_shared_modern.getFluidValue(input[0]);
+      const [t, id] = this.transforms[i](
+        reactSpring_shared_modern.is.arr(arg1) ? arg1 : input.map(reactSpring_shared_modern.getFluidValue)
+      );
+      transform += " " + t;
+      identity = identity && id;
+    });
+    return identity ? "none" : transform;
+  }
+  // Start observing our inputs once we have an observer.
+  observerAdded(count) {
+    if (count == 1)
+      reactSpring_shared_modern.each(
+        this.inputs,
+        (input) => reactSpring_shared_modern.each(
+          input,
+          (value) => reactSpring_shared_modern.hasFluidValue(value) && reactSpring_shared_modern.addFluidObserver(value, this)
+        )
+      );
+  }
+  // Stop observing our inputs once we have no observers.
+  observerRemoved(count) {
+    if (count == 0)
+      reactSpring_shared_modern.each(
+        this.inputs,
+        (input) => reactSpring_shared_modern.each(
+          input,
+          (value) => reactSpring_shared_modern.hasFluidValue(value) && reactSpring_shared_modern.removeFluidObserver(value, this)
+        )
+      );
+  }
+  eventObserved(event) {
+    if (event.type == "change") {
+      this._value = null;
+    }
+    reactSpring_shared_modern.callFluidObservers(this, event);
+  }
+};
+
+// src/primitives.ts
+var primitives = [
+  "a",
+  "abbr",
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "base",
+  "bdi",
+  "bdo",
+  "big",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "keygen",
+  "label",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "map",
+  "mark",
+  "menu",
+  "menuitem",
+  "meta",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "param",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "script",
+  "section",
+  "select",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "style",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "title",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "wbr",
+  // SVG
+  "circle",
+  "clipPath",
+  "defs",
+  "ellipse",
+  "foreignObject",
+  "g",
+  "image",
+  "line",
+  "linearGradient",
+  "mask",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "radialGradient",
+  "rect",
+  "stop",
+  "svg",
+  "text",
+  "tspan"
+];
+reactSpring_shared_modern.Globals.assign({
+  batchedUpdates: reactDom.unstable_batchedUpdates,
+  createStringInterpolator: reactSpring_shared_modern.createStringInterpolator,
+  colors: reactSpring_shared_modern.colors
+});
+var host = reactSpring_animated_modern.createHost(primitives, {
+  applyAnimatedValues,
+  createAnimatedStyle: (style) => new AnimatedStyle(style),
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getComponentProps: ({ scrollTop, scrollLeft, ...props }) => props
+});
+var animated = host.animated;
+
+exports.BailSignal = reactSpring_core_modern.BailSignal;
+exports.Controller = reactSpring_core_modern.Controller;
+exports.FrameValue = reactSpring_core_modern.FrameValue;
+exports.Interpolation = reactSpring_core_modern.Interpolation;
+exports.SpringContext = reactSpring_core_modern.SpringContext;
+exports.SpringRef = reactSpring_core_modern.SpringRef;
+exports.SpringValue = reactSpring_core_modern.SpringValue;
+exports.config = reactSpring_core_modern.config;
+exports.inferTo = reactSpring_core_modern.inferTo;
+exports.useSpring = reactSpring_core_modern.useSpring;
+exports.useSprings = reactSpring_core_modern.useSprings;
+exports.Globals = reactSpring_shared_modern.Globals;
+exports.createInterpolator = reactSpring_shared_modern.createInterpolator;
+exports.easings = reactSpring_shared_modern.easings;
+exports.useIsomorphicLayoutEffect = reactSpring_shared_modern.useIsomorphicLayoutEffect;
+exports.a = animated;
+exports.animated = animated;

package/dist/cjs/bundled_modules/jotai/esm/react.js

@@ -0,0 +1,160 @@
+'use client';
+'use strict';
+
+var React = require('react');
+var vanilla = require('./vanilla.js');
+var internals = require('./vanilla/internals.js');
+
+const StoreContext = React.createContext(
+  void 0
+);
+function useStore(options) {
+  const store = React.useContext(StoreContext);
+  return store || vanilla.getDefaultStore();
+}
+
+const isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === "function";
+const attachPromiseStatus = (promise) => {
+  if (!promise.status) {
+    promise.status = "pending";
+    promise.then(
+      (v) => {
+        promise.status = "fulfilled";
+        promise.value = v;
+      },
+      (e) => {
+        promise.status = "rejected";
+        promise.reason = e;
+      }
+    );
+  }
+};
+const use = React.use || // A shim for older React versions
+((promise) => {
+  if (promise.status === "pending") {
+    throw promise;
+  } else if (promise.status === "fulfilled") {
+    return promise.value;
+  } else if (promise.status === "rejected") {
+    throw promise.reason;
+  } else {
+    attachPromiseStatus(promise);
+    throw promise;
+  }
+});
+const continuablePromiseMap = /* @__PURE__ */ new WeakMap();
+const createContinuablePromise = (promise, getValue) => {
+  let continuablePromise = continuablePromiseMap.get(promise);
+  if (!continuablePromise) {
+    continuablePromise = new Promise((resolve, reject) => {
+      let curr = promise;
+      const onFulfilled = (me) => (v) => {
+        if (curr === me) {
+          resolve(v);
+        }
+      };
+      const onRejected = (me) => (e) => {
+        if (curr === me) {
+          reject(e);
+        }
+      };
+      const onAbort = () => {
+        try {
+          const nextValue = getValue();
+          if (isPromiseLike(nextValue)) {
+            continuablePromiseMap.set(nextValue, continuablePromise);
+            curr = nextValue;
+            nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
+            internals.INTERNAL_registerAbortHandler(nextValue, onAbort);
+          } else {
+            resolve(nextValue);
+          }
+        } catch (e) {
+          reject(e);
+        }
+      };
+      promise.then(onFulfilled(promise), onRejected(promise));
+      internals.INTERNAL_registerAbortHandler(promise, onAbort);
+    });
+    continuablePromiseMap.set(promise, continuablePromise);
+  }
+  return continuablePromise;
+};
+function useAtomValue(atom, options) {
+  const { delay, unstable_promiseStatus: promiseStatus = !React.use } = {};
+  const store = useStore();
+  const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = React.useReducer(
+    (prev) => {
+      const nextValue = store.get(atom);
+      if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {
+        return prev;
+      }
+      return [nextValue, store, atom];
+    },
+    void 0,
+    () => [store.get(atom), store, atom]
+  );
+  let value = valueFromReducer;
+  if (storeFromReducer !== store || atomFromReducer !== atom) {
+    rerender();
+    value = store.get(atom);
+  }
+  React.useEffect(() => {
+    const unsub = store.sub(atom, () => {
+      if (promiseStatus) {
+        try {
+          const value2 = store.get(atom);
+          if (isPromiseLike(value2)) {
+            attachPromiseStatus(
+              createContinuablePromise(value2, () => store.get(atom))
+            );
+          }
+        } catch (e) {
+        }
+      }
+      if (typeof delay === "number") {
+        setTimeout(rerender, delay);
+        return;
+      }
+      rerender();
+    });
+    rerender();
+    return unsub;
+  }, [store, atom, delay, promiseStatus]);
+  React.useDebugValue(value);
+  if (isPromiseLike(value)) {
+    const promise = createContinuablePromise(value, () => store.get(atom));
+    if (promiseStatus) {
+      attachPromiseStatus(promise);
+    }
+    return use(promise);
+  }
+  return value;
+}
+
+function useSetAtom(atom, options) {
+  const store = useStore();
+  const setAtom = React.useCallback(
+    (...args) => {
+      if ((undefined ? undefined.MODE : void 0) !== "production" && !("write" in atom)) {
+        throw new Error("not writable atom");
+      }
+      return store.set(atom, ...args);
+    },
+    [store, atom]
+  );
+  return setAtom;
+}
+
+function useAtom(atom, options) {
+  return [
+    useAtomValue(atom),
+    // We do wrong type assertion here, which results in throwing an error.
+    useSetAtom(atom)
+  ];
+}
+
+exports.useAtom = useAtom;
+exports.useAtomValue = useAtomValue;
+exports.useSetAtom = useSetAtom;
+exports.useStore = useStore;