@class101/cdn-ui-system 0.0.7 → 0.0.11

package/chunk-LE44IRCL.js

@@ -0,0 +1,152 @@
+import {
+  require_react_is
+} from "./chunk-CGEEKALF.js";
+import {
+  __commonJS,
+  init_react_shim
+} from "./chunk-VIIHQGZ3.js";
+
+// node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js
+var require_hoist_non_react_statics_cjs = __commonJS({
+  "node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js"(exports, module) {
+    init_react_shim();
+    "use strict";
+    var reactIs = require_react_is();
+    var REACT_STATICS = {
+      childContextTypes: true,
+      contextType: true,
+      contextTypes: true,
+      defaultProps: true,
+      displayName: true,
+      getDefaultProps: true,
+      getDerivedStateFromError: true,
+      getDerivedStateFromProps: true,
+      mixins: true,
+      propTypes: true,
+      type: true
+    };
+    var KNOWN_STATICS = {
+      name: true,
+      length: true,
+      prototype: true,
+      caller: true,
+      callee: true,
+      arguments: true,
+      arity: true
+    };
+    var FORWARD_REF_STATICS = {
+      "$$typeof": true,
+      render: true,
+      defaultProps: true,
+      displayName: true,
+      propTypes: true
+    };
+    var MEMO_STATICS = {
+      "$$typeof": true,
+      compare: true,
+      defaultProps: true,
+      displayName: true,
+      propTypes: true,
+      type: true
+    };
+    var TYPE_STATICS = {};
+    TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
+    TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
+    function getStatics(component) {
+      if (reactIs.isMemo(component)) {
+        return MEMO_STATICS;
+      }
+      return TYPE_STATICS[component["$$typeof"]] || REACT_STATICS;
+    }
+    var defineProperty = Object.defineProperty;
+    var getOwnPropertyNames = Object.getOwnPropertyNames;
+    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+    var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+    var getPrototypeOf = Object.getPrototypeOf;
+    var objectPrototype = Object.prototype;
+    function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
+      if (typeof sourceComponent !== "string") {
+        if (objectPrototype) {
+          var inheritedComponent = getPrototypeOf(sourceComponent);
+          if (inheritedComponent && inheritedComponent !== objectPrototype) {
+            hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
+          }
+        }
+        var keys = getOwnPropertyNames(sourceComponent);
+        if (getOwnPropertySymbols) {
+          keys = keys.concat(getOwnPropertySymbols(sourceComponent));
+        }
+        var targetStatics = getStatics(targetComponent);
+        var sourceStatics = getStatics(sourceComponent);
+        for (var i = 0; i < keys.length; ++i) {
+          var key = keys[i];
+          if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
+            var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
+            try {
+              defineProperty(targetComponent, key, descriptor);
+            } catch (e) {
+            }
+          }
+        }
+      }
+      return targetComponent;
+    }
+    module.exports = hoistNonReactStatics;
+  }
+});
+
+// node_modules/@emotion/unitless/dist/unitless.browser.esm.js
+init_react_shim();
+var unitlessKeys = {
+  animationIterationCount: 1,
+  borderImageOutset: 1,
+  borderImageSlice: 1,
+  borderImageWidth: 1,
+  boxFlex: 1,
+  boxFlexGroup: 1,
+  boxOrdinalGroup: 1,
+  columnCount: 1,
+  columns: 1,
+  flex: 1,
+  flexGrow: 1,
+  flexPositive: 1,
+  flexShrink: 1,
+  flexNegative: 1,
+  flexOrder: 1,
+  gridRow: 1,
+  gridRowEnd: 1,
+  gridRowSpan: 1,
+  gridRowStart: 1,
+  gridColumn: 1,
+  gridColumnEnd: 1,
+  gridColumnSpan: 1,
+  gridColumnStart: 1,
+  msGridRow: 1,
+  msGridRowSpan: 1,
+  msGridColumn: 1,
+  msGridColumnSpan: 1,
+  fontWeight: 1,
+  lineHeight: 1,
+  opacity: 1,
+  order: 1,
+  orphans: 1,
+  tabSize: 1,
+  widows: 1,
+  zIndex: 1,
+  zoom: 1,
+  WebkitLineClamp: 1,
+  fillOpacity: 1,
+  floodOpacity: 1,
+  stopOpacity: 1,
+  strokeDasharray: 1,
+  strokeDashoffset: 1,
+  strokeMiterlimit: 1,
+  strokeOpacity: 1,
+  strokeWidth: 1
+};
+var unitless_browser_esm_default = unitlessKeys;
+
+export {
+  require_hoist_non_react_statics_cjs,
+  unitless_browser_esm_default
+};

package/chunk-LN36XQS3.js

@@ -0,0 +1,47 @@
+import {
+  init_react_shim
+} from "./chunk-VIIHQGZ3.js";
+
+// libs/shared/utils-browser/src/lib/isServer.ts
+init_react_shim();
+var isServer = typeof window === "undefined";
+
+// libs/shared/utils-browser/src/lib/canUseDOM.ts
+init_react_shim();
+
+// libs/shared/utils-browser/src/lib/isBrowser.ts
+init_react_shim();
+var isBrowser = !isServer;
+
+// libs/shared/utils-browser/src/lib/canUseDOM.ts
+var canUseDOM = Boolean(isBrowser && window.document && window.document.createElement);
+
+// libs/shared/utils-browser/src/lib/findOrCreateElementById.ts
+init_react_shim();
+function findOrCreateElementById(id) {
+  const existingElement = document.getElementById(id);
+  if (existingElement) {
+    return existingElement;
+  }
+  const container = document.createElement("div");
+  container.id = id;
+  document.body.appendChild(container);
+  return container;
+}
+
+// libs/shared/utils-browser/src/lib/isExternalUrl.ts
+init_react_shim();
+var HTTP_REGEXP = /^(http|https):\/\//;
+function isExternalUrl(path) {
+  return HTTP_REGEXP.test(path.toLowerCase());
+}
+
+// libs/shared/utils-browser/src/index.ts
+init_react_shim();
+
+export {
+  isServer,
+  canUseDOM,
+  findOrCreateElementById,
+  isExternalUrl
+};

package/chunk-MBYCGPJ2.js

@@ -0,0 +1,29 @@
+import {
+  init_react_shim
+} from "./chunk-VIIHQGZ3.js";
+
+// libs/shared/utils-type/src/lib/isDefined/isDefined.ts
+init_react_shim();
+function isDefined(value) {
+  return value !== void 0;
+}
+
+// libs/shared/utils-type/src/lib/isDefined/index.ts
+init_react_shim();
+
+// libs/shared/utils-type/src/lib/isTruthy/isTruthy.ts
+init_react_shim();
+function isTruthy(value) {
+  return Boolean(value);
+}
+
+// libs/shared/utils-type/src/lib/isTruthy/index.ts
+init_react_shim();
+
+// libs/shared/utils-type/src/index.ts
+init_react_shim();
+
+export {
+  isDefined,
+  isTruthy
+};

package/chunk-O6RRFC57.js

@@ -0,0 +1,255 @@
+import {
+  canUseDOM
+} from "./chunk-LN36XQS3.js";
+import {
+  __commonJS,
+  __toModule,
+  init_react_shim
+} from "./chunk-VIIHQGZ3.js";
+
+// node_modules/react-fast-compare/index.js
+var require_react_fast_compare = __commonJS({
+  "node_modules/react-fast-compare/index.js"(exports, module) {
+    init_react_shim();
+    var hasElementType = typeof Element !== "undefined";
+    var hasMap = typeof Map === "function";
+    var hasSet = typeof Set === "function";
+    var hasArrayBuffer = typeof ArrayBuffer === "function" && !!ArrayBuffer.isView;
+    function equal(a, b) {
+      if (a === b)
+        return true;
+      if (a && b && typeof a == "object" && typeof b == "object") {
+        if (a.constructor !== b.constructor)
+          return false;
+        var length, i, keys;
+        if (Array.isArray(a)) {
+          length = a.length;
+          if (length != b.length)
+            return false;
+          for (i = length; i-- !== 0; )
+            if (!equal(a[i], b[i]))
+              return false;
+          return true;
+        }
+        var it;
+        if (hasMap && a instanceof Map && b instanceof Map) {
+          if (a.size !== b.size)
+            return false;
+          it = a.entries();
+          while (!(i = it.next()).done)
+            if (!b.has(i.value[0]))
+              return false;
+          it = a.entries();
+          while (!(i = it.next()).done)
+            if (!equal(i.value[1], b.get(i.value[0])))
+              return false;
+          return true;
+        }
+        if (hasSet && a instanceof Set && b instanceof Set) {
+          if (a.size !== b.size)
+            return false;
+          it = a.entries();
+          while (!(i = it.next()).done)
+            if (!b.has(i.value[0]))
+              return false;
+          return true;
+        }
+        if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+          length = a.length;
+          if (length != b.length)
+            return false;
+          for (i = length; i-- !== 0; )
+            if (a[i] !== b[i])
+              return false;
+          return true;
+        }
+        if (a.constructor === RegExp)
+          return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf)
+          return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString)
+          return a.toString() === b.toString();
+        keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length)
+          return false;
+        for (i = length; i-- !== 0; )
+          if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+            return false;
+        if (hasElementType && a instanceof Element)
+          return false;
+        for (i = length; i-- !== 0; ) {
+          if ((keys[i] === "_owner" || keys[i] === "__v" || keys[i] === "__o") && a.$$typeof) {
+            continue;
+          }
+          if (!equal(a[keys[i]], b[keys[i]]))
+            return false;
+        }
+        return true;
+      }
+      return a !== a && b !== b;
+    }
+    module.exports = function isEqual2(a, b) {
+      try {
+        return equal(a, b);
+      } catch (error) {
+        if ((error.message || "").match(/stack|recursion/i)) {
+          console.warn("react-fast-compare cannot handle circular refs");
+          return false;
+        }
+        throw error;
+      }
+    };
+  }
+});
+
+// libs/shared/utils-hooks/src/lib/useDeepCompareMemo/useDeepCompareMemo.ts
+init_react_shim();
+import { useMemo } from "react";
+
+// libs/shared/utils-hooks/src/lib/useDeepCompareDeps/index.ts
+init_react_shim();
+
+// libs/shared/utils-hooks/src/lib/useDeepCompareDeps/useDeepCompareDeps.ts
+init_react_shim();
+var import_react_fast_compare = __toModule(require_react_fast_compare());
+import { useRef } from "react";
+function useDeepCompareDeps(value) {
+  const ref = useRef(value);
+  if (!(0, import_react_fast_compare.default)(value, ref.current)) {
+    ref.current = value;
+  }
+  return ref.current;
+}
+
+// libs/shared/utils-hooks/src/lib/useDeepCompareMemo/useDeepCompareMemo.ts
+function useDeepCompareMemo(factory, deps) {
+  return useMemo(factory, useDeepCompareDeps(deps));
+}
+
+// libs/shared/utils-hooks/src/lib/useDeepCompareMemo/index.ts
+init_react_shim();
+
+// libs/shared/utils-hooks/src/lib/useInView/useInView.tsx
+init_react_shim();
+import { useCallback as useCallback2, useState } from "react";
+
+// libs/shared/utils-hooks/src/lib/useIntersectionObserver/index.ts
+init_react_shim();
+
+// libs/shared/utils-hooks/src/lib/useIntersectionObserver/useIntersectionObserver.ts
+init_react_shim();
+import { useCallback, useEffect, useRef as useRef2 } from "react";
+var useIntersectionObserver = (callback, options) => {
+  const observerRef = useRef2();
+  const handleIntersection = useCallback(([entry]) => {
+    callback(entry);
+  }, [callback]);
+  const observe = useCallback((node) => {
+    if (!node) {
+      return;
+    }
+    observerRef.current = new IntersectionObserver(handleIntersection, options);
+    observerRef.current.observe(node);
+  }, [handleIntersection, options]);
+  const unobserve = useCallback(() => {
+    var _a;
+    (_a = observerRef.current) == null ? void 0 : _a.disconnect();
+    observerRef.current = void 0;
+  }, []);
+  const ref = useCallback((node) => {
+    unobserve();
+    observe(node);
+  }, [observe, unobserve]);
+  useEffect(() => unobserve, [unobserve]);
+  return { ref };
+};
+
+// libs/shared/utils-hooks/src/lib/useInView/useInView.tsx
+var useInView = (initialInView, options) => {
+  const [isInView, setIsInView] = useState(initialInView);
+  const callback = useCallback2((entry) => {
+    if (entry.isIntersecting) {
+      setIsInView(true);
+    } else {
+      setIsInView(false);
+    }
+  }, []);
+  const { ref } = useIntersectionObserver(callback, options);
+  return { ref, isInView };
+};
+
+// libs/shared/utils-hooks/src/lib/useInView/index.ts
+init_react_shim();
+
+// libs/shared/utils-hooks/src/lib/useLazyUnmount/useLazyUnmount.ts
+init_react_shim();
+import { useEffect as useEffect2, useState as useState2 } from "react";
+var useLazyUnmount = (state, delay) => {
+  const [isMounted, setIsMounted] = useState2(state);
+  useEffect2(() => {
+    if (state) {
+      setIsMounted(state);
+      return void 0;
+    }
+    const timer = setTimeout(() => {
+      setIsMounted(false);
+    }, delay);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [delay, state]);
+  return isMounted;
+};
+
+// libs/shared/utils-hooks/src/lib/useLazyUnmount/index.ts
+init_react_shim();
+
+// libs/shared/utils-hooks/src/lib/useLockBodyScroll/useLockBodyScroll.ts
+init_react_shim();
+import { useEffect as useEffect3, useRef as useRef3 } from "react";
+var useLockBodyScroll = (locked = false) => {
+  const bodyStyleRef = useRef3({ paddingRight: "", overflow: "" });
+  const lockBodyScroll = () => {
+    if (!canUseDOM) {
+      return;
+    }
+    bodyStyleRef.current = {
+      paddingRight: document.body.style.paddingRight,
+      overflow: document.body.style.overflow
+    };
+    const scrollBarWidth = window.innerWidth - document.documentElement.clientWidth;
+    document.body.style.paddingRight = `${scrollBarWidth}px`;
+    document.body.style.overflow = "hidden";
+  };
+  const unlockBodyScroll = () => {
+    if (!canUseDOM) {
+      return;
+    }
+    document.body.style.paddingRight = bodyStyleRef.current.paddingRight;
+    document.body.style.overflow = bodyStyleRef.current.overflow;
+  };
+  useEffect3(() => {
+    if (locked) {
+      lockBodyScroll();
+    } else {
+      unlockBodyScroll();
+    }
+    return () => {
+      unlockBodyScroll();
+    };
+  }, [locked]);
+};
+
+// libs/shared/utils-hooks/src/lib/useLockBodyScroll/index.ts
+init_react_shim();
+
+// libs/shared/utils-hooks/src/index.ts
+init_react_shim();
+
+export {
+  useDeepCompareMemo,
+  useInView,
+  useLazyUnmount,
+  useLockBodyScroll
+};

package/chunk-QNI6E7MT.js

@@ -0,0 +1,39 @@
+import {
+  init_react_shim
+} from "./chunk-VIIHQGZ3.js";
+
+// libs/shared/utils-string/src/lib/convertToSecureUrl/convertToSecureUrl.ts
+init_react_shim();
+function convertToSecureUrl(url) {
+  return url.replace(/^https?:\/\//i, "https://");
+}
+
+// libs/shared/utils-string/src/lib/convertToSecureUrl/index.ts
+init_react_shim();
+
+// libs/shared/utils-string/src/lib/nl2br/nl2br.ts
+init_react_shim();
+import { createElement } from "react";
+var newlineRegex = /(\r\n|\n\r|\r|\n|\\n)/g;
+function nl2br(string) {
+  if (typeof string !== "string") {
+    return string;
+  }
+  return string.split(newlineRegex).map((line, index) => {
+    if (line.match(newlineRegex)) {
+      return createElement("br", { key: index.toString() });
+    }
+    return line;
+  });
+}
+
+// libs/shared/utils-string/src/lib/nl2br/index.ts
+init_react_shim();
+
+// libs/shared/utils-string/src/index.ts
+init_react_shim();
+
+export {
+  convertToSecureUrl,
+  nl2br
+};

package/chunk-R4HM35UZ.js

@@ -0,0 +1,84 @@
+import {
+  __commonJS,
+  init_react_shim
+} from "./chunk-VIIHQGZ3.js";
+
+// node_modules/object-assign/index.js
+var require_object_assign = __commonJS({
+  "node_modules/object-assign/index.js"(exports, module) {
+    init_react_shim();
+    "use strict";
+    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+    function toObject(val) {
+      if (val === null || val === void 0) {
+        throw new TypeError("Object.assign cannot be called with null or undefined");
+      }
+      return Object(val);
+    }
+    function shouldUseNative() {
+      try {
+        if (!Object.assign) {
+          return false;
+        }
+        var test1 = new String("abc");
+        test1[5] = "de";
+        if (Object.getOwnPropertyNames(test1)[0] === "5") {
+          return false;
+        }
+        var test2 = {};
+        for (var i = 0; i < 10; i++) {
+          test2["_" + String.fromCharCode(i)] = i;
+        }
+        var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
+          return test2[n];
+        });
+        if (order2.join("") !== "0123456789") {
+          return false;
+        }
+        var test3 = {};
+        "abcdefghijklmnopqrst".split("").forEach(function(letter) {
+          test3[letter] = letter;
+        });
+        if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
+          return false;
+        }
+        return true;
+      } catch (err) {
+        return false;
+      }
+    }
+    module.exports = shouldUseNative() ? Object.assign : function(target, source) {
+      var from;
+      var to = toObject(target);
+      var symbols;
+      for (var s = 1; s < arguments.length; s++) {
+        from = Object(arguments[s]);
+        for (var key in from) {
+          if (hasOwnProperty.call(from, key)) {
+            to[key] = from[key];
+          }
+        }
+        if (getOwnPropertySymbols) {
+          symbols = getOwnPropertySymbols(from);
+          for (var i = 0; i < symbols.length; i++) {
+            if (propIsEnumerable.call(from, symbols[i])) {
+              to[symbols[i]] = from[symbols[i]];
+            }
+          }
+        }
+      }
+      return to;
+    };
+  }
+});
+
+export {
+  require_object_assign
+};
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/