@hairy/react-lib 1.1.2 → 1.6.0

package/dist/index.global.js

@@ -0,0 +1,526 @@
+"use strict";
+var LibReact = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // globals:react
+  var require_react = __commonJS({
+    "globals:react"(exports, module) {
+      "use strict";
+      module.exports = React;
+    }
+  });
+
+  // ../../node_modules/.pnpm/void-elements@3.1.0/node_modules/void-elements/index.js
+  var require_void_elements = __commonJS({
+    "../../node_modules/.pnpm/void-elements@3.1.0/node_modules/void-elements/index.js"(exports, module) {
+      "use strict";
+      module.exports = {
+        "area": true,
+        "base": true,
+        "br": true,
+        "col": true,
+        "embed": true,
+        "hr": true,
+        "img": true,
+        "input": true,
+        "link": true,
+        "meta": true,
+        "param": true,
+        "source": true,
+        "track": true,
+        "wbr": true
+      };
+    }
+  });
+
+  // globals:react-i18next
+  var require_react_i18next = __commonJS({
+    "globals:react-i18next"(exports, module) {
+      "use strict";
+      module.exports = reactI18next;
+    }
+  });
+
+  // ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
+  var __assign;
+  var init_tslib_es6 = __esm({
+    "../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs"() {
+      "use strict";
+      __assign = function() {
+        __assign = Object.assign || function __assign2(t2) {
+          for (var s2, i2 = 1, n2 = arguments.length; i2 < n2; i2++) {
+            s2 = arguments[i2];
+            for (var p in s2) if (Object.prototype.hasOwnProperty.call(s2, p)) t2[p] = s2[p];
+          }
+          return t2;
+        };
+        return __assign.apply(this, arguments);
+      };
+    }
+  });
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    Case: () => Case,
+    Default: () => Default,
+    Else: () => Else,
+    If: () => If,
+    Injector: () => Injector,
+    Switch: () => Switch,
+    Then: () => Then,
+    Trans: () => Trans,
+    Unless: () => Unless,
+    cls: () => cls,
+    useAsyncCallback: () => useAsyncCallback,
+    useAsyncState: () => useAsyncState,
+    useDebounce: () => useDebounce,
+    useEventBus: () => useEventBus,
+    useFetchRequestIntercept: () => useFetchRequestIntercept,
+    useFetchResponseIntercept: () => useFetchResponseIntercept,
+    useMounted: () => useMounted,
+    useWatch: () => useWatch,
+    useWhenever: () => useWhenever
+  });
+
+  // src/components/condition/Case.ts
+  function Case(props) {
+    return props.children;
+  }
+
+  // src/components/condition/Default.ts
+  function Default(props) {
+    return props.children;
+  }
+
+  // src/components/condition/Else.ts
+  function Else(props) {
+    return props.children;
+  }
+
+  // src/components/condition/If.ts
+  var import_react = __toESM(require_react(), 1);
+
+  // src/components/condition/Then.ts
+  function Then(props) {
+    return props.children;
+  }
+
+  // src/components/condition/If.ts
+  function If(props) {
+    const children = props.then || props.children;
+    const elements = import_react.Children.toArray(children);
+    const thenChild = elements.find((c2) => c2.type === Then);
+    const elseChild = elements.find((c2) => c2.type === Else);
+    return thenChild || elseChild ? props.cond ? thenChild : elseChild : props.cond ? children : props.else;
+  }
+
+  // src/components/condition/Switch.ts
+  var import_react2 = __toESM(require_react(), 1);
+  function Switch(props) {
+    const isUseValue = props.value !== void 0;
+    let matchingCase;
+    let defaultCase;
+    import_react2.Children.forEach(props.children, (child) => {
+      if (!(0, import_react2.isValidElement)(child) || matchingCase)
+        return;
+      if (child.type === Case) {
+        const cond = child.props.cond;
+        if (isUseValue ? props.value === cond : cond) {
+          matchingCase = child;
+          return;
+        }
+      }
+      if (!defaultCase && child.type === Default)
+        defaultCase = child;
+    });
+    return matchingCase ?? defaultCase ?? null;
+  }
+
+  // src/components/condition/Unless.ts
+  var import_react3 = __toESM(require_react(), 1);
+  function Unless(props) {
+    const children = props.then || props.children;
+    const elements = import_react3.Children.toArray(children);
+    const thenChild = elements.find((c2) => c2.type === Then);
+    const elseChild = elements.find((c2) => c2.type === Else);
+    return thenChild || elseChild ? !props.cond ? elseChild : thenChild : !props.cond ? props.children : props.else;
+  }
+
+  // src/components/utils/Injector.ts
+  var import_react4 = __toESM(require_react(), 1);
+  function Injector(props) {
+    const installs = (0, import_react4.useMemo)(
+      () => props.install.map(repack).reverse(),
+      [props.install]
+    );
+    return installs.reduce(
+      (child, { component: Component, props: props2 }) => (0, import_react4.createElement)(Component, props2, child),
+      props.children
+    );
+  }
+  function repack(c2) {
+    return c2.component ? c2 : { component: c2 };
+  }
+
+  // ../../node_modules/.pnpm/html-parse-stringify@3.0.1/node_modules/html-parse-stringify/dist/html-parse-stringify.module.js
+  var import_void_elements = __toESM(require_void_elements());
+  var t = /\s([^'"/\s><]+?)[\s/>]|([^\s=]+)=\s?(".*?"|'.*?')/g;
+  function n(n2) {
+    var r2 = { type: "tag", name: "", voidElement: false, attrs: {}, children: [] }, i2 = n2.match(/<\/?([^\s]+?)[/\s>]/);
+    if (i2 && (r2.name = i2[1], (import_void_elements.default[i2[1]] || "/" === n2.charAt(n2.length - 2)) && (r2.voidElement = true), r2.name.startsWith("!--"))) {
+      var s2 = n2.indexOf("-->");
+      return { type: "comment", comment: -1 !== s2 ? n2.slice(4, s2) : "" };
+    }
+    for (var a2 = new RegExp(t), c2 = null; null !== (c2 = a2.exec(n2)); ) if (c2[0].trim()) if (c2[1]) {
+      var o = c2[1].trim(), l = [o, ""];
+      o.indexOf("=") > -1 && (l = o.split("=")), r2.attrs[l[0]] = l[1], a2.lastIndex--;
+    } else c2[2] && (r2.attrs[c2[2]] = c2[3].trim().substring(1, c2[3].length - 1));
+    return r2;
+  }
+  var r = /<[a-zA-Z0-9\-\!\/](?:"[^"]*"|'[^']*'|[^'">])*>/g;
+  var i = /^\s*$/;
+  var s = /* @__PURE__ */ Object.create(null);
+  function a(e2, t2) {
+    switch (t2.type) {
+      case "text":
+        return e2 + t2.content;
+      case "tag":
+        return e2 += "<" + t2.name + (t2.attrs ? function(e3) {
+          var t3 = [];
+          for (var n2 in e3) t3.push(n2 + '="' + e3[n2] + '"');
+          return t3.length ? " " + t3.join(" ") : "";
+        }(t2.attrs) : "") + (t2.voidElement ? "/>" : ">"), t2.voidElement ? e2 : e2 + t2.children.reduce(a, "") + "</" + t2.name + ">";
+      case "comment":
+        return e2 + "<!--" + t2.comment + "-->";
+    }
+  }
+  var c = { parse: function(e2, t2) {
+    t2 || (t2 = {}), t2.components || (t2.components = s);
+    var a2, c2 = [], o = [], l = -1, m = false;
+    if (0 !== e2.indexOf("<")) {
+      var u = e2.indexOf("<");
+      c2.push({ type: "text", content: -1 === u ? e2 : e2.substring(0, u) });
+    }
+    return e2.replace(r, function(r2, s2) {
+      if (m) {
+        if (r2 !== "</" + a2.name + ">") return;
+        m = false;
+      }
+      var u2, f = "/" !== r2.charAt(1), h = r2.startsWith("<!--"), p = s2 + r2.length, d = e2.charAt(p);
+      if (h) {
+        var v = n(r2);
+        return l < 0 ? (c2.push(v), c2) : ((u2 = o[l]).children.push(v), c2);
+      }
+      if (f && (l++, "tag" === (a2 = n(r2)).type && t2.components[a2.name] && (a2.type = "component", m = true), a2.voidElement || m || !d || "<" === d || a2.children.push({ type: "text", content: e2.slice(p, e2.indexOf("<", p)) }), 0 === l && c2.push(a2), (u2 = o[l - 1]) && u2.children.push(a2), o[l] = a2), (!f || a2.voidElement) && (l > -1 && (a2.voidElement || a2.name === r2.slice(2, -1)) && (l--, a2 = -1 === l ? c2 : o[l]), !m && "<" !== d && d)) {
+        u2 = -1 === l ? c2 : o[l].children;
+        var x = e2.indexOf("<", p), g = e2.slice(p, -1 === x ? void 0 : x);
+        i.test(g) && (g = " "), (x > -1 && l + u2.length >= 0 || " " !== g) && u2.push({ type: "text", content: g });
+      }
+    }), c2;
+  }, stringify: function(e2) {
+    return e2.reduce(function(e3, t2) {
+      return e3 + a("", t2);
+    }, "");
+  } };
+  var html_parse_stringify_module_default = c;
+
+  // src/components/utils/Trans.ts
+  var import_react5 = __toESM(require_react(), 1);
+  var import_react_i18next = __toESM(require_react_i18next(), 1);
+  function Trans({ i18nKey, ...additionalProps }) {
+    const translation = (0, import_react_i18next.useTranslation)().t(i18nKey, additionalProps);
+    return renderNodes(html_parse_stringify_module_default.parse(translation), additionalProps);
+  }
+  function renderNodes(tokens, values) {
+    let index = 0;
+    return tokens.map((token) => {
+      if (token.type === "text")
+        return token.content;
+      index++;
+      const props = { ...token.attrs, key: index };
+      return token.voidElement ? values[token.name] ? (0, import_react5.createElement)("span", { key: index }, values[token.name]) : (0, import_react5.createElement)(token.name, props) : (0, import_react5.createElement)(token.name, props, renderNodes(token.children, {}));
+    });
+  }
+
+  // src/hooks/useAsyncCallback.ts
+  var import_react6 = __toESM(require_react(), 1);
+  function useAsyncCallback(fun) {
+    const [error, setError] = (0, import_react6.useState)();
+    const [loading, setLoading] = (0, import_react6.useState)(false);
+    async function execute(...args) {
+      try {
+        setLoading(true);
+        const result = await fun(...args);
+        setLoading(false);
+        return result;
+      } catch (error2) {
+        setLoading(false);
+        setError(error2);
+        throw error2;
+      }
+    }
+    return [loading, execute, error];
+  }
+
+  // ../../node_modules/.pnpm/react-use@17.6.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-use/esm/useAsyncFn.js
+  init_tslib_es6();
+  var import_react8 = __toESM(require_react());
+
+  // ../../node_modules/.pnpm/react-use@17.6.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-use/esm/useMountedState.js
+  var import_react7 = __toESM(require_react());
+  function useMountedState() {
+    var mountedRef = (0, import_react7.useRef)(false);
+    var get = (0, import_react7.useCallback)(function() {
+      return mountedRef.current;
+    }, []);
+    (0, import_react7.useEffect)(function() {
+      mountedRef.current = true;
+      return function() {
+        mountedRef.current = false;
+      };
+    }, []);
+    return get;
+  }
+
+  // ../../node_modules/.pnpm/react-use@17.6.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-use/esm/useAsyncFn.js
+  function useAsyncFn(fn, deps, initialState) {
+    if (deps === void 0) {
+      deps = [];
+    }
+    if (initialState === void 0) {
+      initialState = { loading: false };
+    }
+    var lastCallId = (0, import_react8.useRef)(0);
+    var isMounted = useMountedState();
+    var _a = (0, import_react8.useState)(initialState), state = _a[0], set = _a[1];
+    var callback = (0, import_react8.useCallback)(function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      var callId = ++lastCallId.current;
+      if (!state.loading) {
+        set(function(prevState) {
+          return __assign(__assign({}, prevState), { loading: true });
+        });
+      }
+      return fn.apply(void 0, args).then(function(value) {
+        isMounted() && callId === lastCallId.current && set({ value, loading: false });
+        return value;
+      }, function(error) {
+        isMounted() && callId === lastCallId.current && set({ error, loading: false });
+        return error;
+      });
+    }, deps);
+    return [state, callback];
+  }
+
+  // ../../node_modules/.pnpm/react-use@17.6.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-use/esm/useEffectOnce.js
+  var import_react9 = __toESM(require_react());
+  var useEffectOnce = function(effect) {
+    (0, import_react9.useEffect)(effect, []);
+  };
+  var useEffectOnce_default = useEffectOnce;
+
+  // ../../node_modules/.pnpm/react-use@17.6.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-use/esm/useMount.js
+  var useMount = function(fn) {
+    useEffectOnce_default(function() {
+      fn();
+    });
+  };
+  var useMount_default = useMount;
+
+  // src/hooks/useAsyncState.ts
+  function useAsyncState(fn, deps, options) {
+    const [state, _fn] = useAsyncFn(fn, deps, options?.initial);
+    useMount_default(() => options?.immediate && _fn());
+    return [state, _fn];
+  }
+
+  // src/hooks/useDebounce.ts
+  var import_react10 = __toESM(require_react(), 1);
+  function useDebounce(value, delay) {
+    const [debouncedValue, setDebouncedValue] = (0, import_react10.useState)(value);
+    (0, import_react10.useEffect)(() => {
+      const handler = setTimeout(() => setDebouncedValue(value), delay);
+      return () => clearTimeout(handler);
+    }, [value, delay]);
+    return debouncedValue;
+  }
+
+  // ../../node_modules/.pnpm/mitt@3.0.1/node_modules/mitt/dist/mitt.mjs
+  function mitt_default(n2) {
+    return { all: n2 = n2 || /* @__PURE__ */ new Map(), on: function(t2, e2) {
+      var i2 = n2.get(t2);
+      i2 ? i2.push(e2) : n2.set(t2, [e2]);
+    }, off: function(t2, e2) {
+      var i2 = n2.get(t2);
+      i2 && (e2 ? i2.splice(i2.indexOf(e2) >>> 0, 1) : n2.set(t2, []));
+    }, emit: function(t2, e2) {
+      var i2 = n2.get(t2);
+      i2 && i2.slice().map(function(n3) {
+        n3(e2);
+      }), (i2 = n2.get("*")) && i2.slice().map(function(n3) {
+        n3(t2, e2);
+      });
+    } };
+  }
+
+  // src/hooks/useEventBus.ts
+  var import_react11 = __toESM(require_react(), 1);
+  var emitter = mitt_default();
+  function useEventBus(key) {
+    const onRef = (0, import_react11.useRef)();
+    function on(listener) {
+      emitter.on(key, listener);
+      onRef.current = listener;
+      (0, import_react11.useEffect)(() => {
+        if (!onRef.current)
+          return;
+        emitter.off(key, onRef.current);
+        emitter.on(key, listener);
+        onRef.current = listener;
+        return () => emitter.off(key, listener);
+      }, [listener]);
+    }
+    function emit(event) {
+      emitter.emit(key, event);
+    }
+    function off(listener) {
+      emitter.off(key, listener);
+    }
+    return {
+      on,
+      emit,
+      off
+    };
+  }
+
+  // src/hooks/useFetchIntercept.ts
+  function useFetchResponseIntercept(intercept) {
+    useMount_default(() => fetchResponseIntercept(intercept));
+  }
+  function useFetchRequestIntercept(intercept) {
+    useMount_default(() => fetchRequestIntercept(intercept));
+  }
+  function fetchResponseIntercept(intercept) {
+    const { fetch: originalFetch } = window;
+    window.fetch = async (...args) => {
+      const [resource, config] = args;
+      const response = await originalFetch(resource, config);
+      return intercept(response);
+    };
+  }
+  function fetchRequestIntercept(intercept) {
+    const { fetch: originalFetch } = window;
+    window.fetch = async (...args) => {
+      const [resource, config] = args;
+      return intercept(originalFetch, resource, config);
+    };
+  }
+
+  // src/hooks/useMounted.ts
+  var import_react12 = __toESM(require_react(), 1);
+  function useMounted() {
+    const [mounted, setMounted] = (0, import_react12.useState)(false);
+    (0, import_react12.useEffect)(() => setMounted(true), []);
+    return mounted;
+  }
+
+  // src/hooks/useWatch.ts
+  var import_react13 = __toESM(require_react(), 1);
+  function useWatch(source, callback, options = {}) {
+    const firstUpdate = (0, import_react13.useRef)(false);
+    const then = (0, import_react13.useRef)();
+    const deps = (0, import_react13.useMemo)(
+      () => Array.isArray(source) ? source : [source],
+      [source]
+    );
+    (0, import_react13.useEffect)(() => {
+      if (!firstUpdate.current)
+        recordFirst();
+      else
+        callback(source);
+    }, deps);
+    async function recordFirst() {
+      if (then.current)
+        return;
+      then.current = Promise.resolve(source);
+      then.current.then(() => firstUpdate.current = true);
+      if (options.immediate)
+        then.current.then((value) => callback(value));
+    }
+  }
+
+  // src/hooks/useWhenever.ts
+  function useWhenever(source, cb, options) {
+    useWatch(source, () => source && cb(source), options);
+  }
+
+  // src/utils/index.ts
+  var hasOwn = {}.hasOwnProperty;
+  function cls(...args) {
+    let classes = "";
+    for (let i2 = 0; i2 < arguments.length; i2++) {
+      const arg = arguments[i2];
+      if (arg)
+        classes = appendClass(classes, parseValue(arg));
+    }
+    return classes;
+  }
+  function parseValue(arg) {
+    if (typeof arg === "string")
+      return arg;
+    if (typeof arg !== "object")
+      return "";
+    if (Array.isArray(arg))
+      return cls.apply(null, arg);
+    if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes("[native code]"))
+      return cls.toString();
+    let classes = "";
+    for (const key in arg) {
+      if (hasOwn.call(arg, key) && arg[key])
+        classes = appendClass(classes, key);
+    }
+    return classes;
+  }
+  function appendClass(value, newClass) {
+    if (!newClass)
+      return value;
+    return value ? `${value} ${newClass}` : newClass;
+  }
+  return __toCommonJS(index_exports);
+})();