@hairy/react-lib-composition 1.29.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-PRESENT Hairyf <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# @hairy/react-lib
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![bundle][bundle-src]][bundle-href]
+[![JSDocs][jsdocs-src]][jsdocs-href]
+[![License][license-src]][license-href]
+
+## Install
+
+```
+ni @hairy/react-lib
+```
+
+## CDN
+
+```html
+<script src="https://unpkg.com/@hairy/react-lib"></script>
+```
+
+## License
+
+[MIT](./LICENSE) License © [Hairyf](https://github.com/hairyf)
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/@hairy/react-lib?style=flat&colorA=080f12&colorB=1fa669
+[npm-version-href]: https://npmjs.com/package/@hairy/react-lib
+[npm-downloads-src]: https://img.shields.io/npm/dm/@hairy/react-lib?style=flat&colorA=080f12&colorB=1fa669
+[npm-downloads-href]: https://npmjs.com/package/@hairy/react-lib
+[bundle-src]: https://img.shields.io/bundlephobia/minzip/@hairy/react-lib?style=flat&colorA=080f12&colorB=1fa669&label=minzip
+[bundle-href]: https://bundlephobia.com/result?p=@hairy/react-lib
+[license-src]: https://img.shields.io/github/license/hairyf/hairylib.svg?style=flat&colorA=080f12&colorB=1fa669
+[license-href]: https://github.com/hairyf/hairylib/blob/main/LICENSE
+[jsdocs-src]: https://img.shields.io/badge/jsdocs-reference-080f12?style=flat&colorA=080f12&colorB=1fa669
+[jsdocs-href]: https://www.jsdocs.io/package/@hairy/react-lib

package/dist/index.cjs

@@ -0,0 +1,487 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Fragment: () => import_react9.Fragment,
+  TransitionGroup: () => TransitionGroup,
+  computed: () => computed,
+  customRef: () => customRef,
+  defineComponent: () => defineComponent,
+  effectScope: () => effectScope,
+  getCurrentInstance: () => getCurrentInstance,
+  getCurrentScope: () => getCurrentScope,
+  h: () => import_react9.createElement,
+  hasInjectionContext: () => hasInjectionContext,
+  inject: () => inject,
+  isProxy: () => import_reactivity8.isProxy,
+  isReactive: () => import_reactivity8.isReactive,
+  isReadonly: () => import_reactivity8.isReadonly,
+  isRef: () => import_reactivity8.isRef,
+  isShallow: () => import_reactivity8.isShallow,
+  markRaw: () => import_reactivity8.markRaw,
+  nextTick: () => nextTick,
+  onBeforeMount: () => onBeforeMount,
+  onBeforeUnmount: () => onBeforeUnmount,
+  onBeforeUpdate: () => onBeforeUpdate,
+  onMounted: () => onMounted,
+  onScopeDispose: () => onScopeDispose,
+  onUnmounted: () => onUnmounted,
+  onUpdated: () => onUpdated,
+  provide: () => provide,
+  reactive: () => reactive,
+  reactivity: () => reactivity,
+  readonly: () => readonly,
+  ref: () => ref,
+  shallowReactive: () => shallowReactive,
+  shallowReadonly: () => shallowReadonly,
+  shallowRef: () => shallowRef,
+  toRaw: () => import_reactivity8.toRaw,
+  toReactive: () => import_reactivity8.toReactive,
+  toReadonly: () => import_reactivity8.toReadonly,
+  toRef: () => import_reactivity8.toRef,
+  toRefs: () => import_reactivity8.toRefs,
+  toValue: () => import_reactivity8.toValue,
+  unref: () => import_reactivity8.unref,
+  watch: () => watch,
+  watchEffect: () => watchEffect,
+  withEffectScope: () => withEffectScope
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal_default = freeGlobal;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Symbol.js
+var Symbol2 = root_default.Symbol;
+var Symbol_default = Symbol2;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var getRawTag_default = getRawTag;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isFunction.js
+var asyncTag = "[object AsyncFunction]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject_default(value)) {
+    return false;
+  }
+  var tag = baseGetTag_default(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_default = isFunction;
+
+// ../util-core/src/util/noop.ts
+var noop = () => {
+};
+
+// ../lib-react/src/hooks/tryUseCallback.ts
+var import_react = require("react");
+var tryUseCallback = (callback, deps) => {
+  try {
+    return (0, import_react.useCallback)(callback, deps);
+  } catch {
+    return callback;
+  }
+};
+
+// ../lib-react/src/hooks/tryUseEffect.ts
+var import_react2 = require("react");
+var tryUseEffect = (effect, deps) => {
+  try {
+    (0, import_react2.useEffect)(effect, deps);
+  } catch {
+  }
+};
+
+// ../lib-react/src/hooks/tryUseInsertionEffect.ts
+var import_react3 = require("react");
+var tryUseInsertionEffect = (callback, deps) => {
+  try {
+    (0, import_react3.useInsertionEffect)(callback, deps);
+  } catch {
+  }
+};
+
+// ../lib-react/src/hooks/tryUseReducer.ts
+var import_react4 = require("react");
+var tryUseReducer = (reducer, initializerArg, initializer) => {
+  try {
+    return (0, import_react4.useReducer)(reducer, initializerArg, initializer);
+  } catch {
+    return [initializerArg, () => {
+    }];
+  }
+};
+
+// ../lib-react/src/hooks/tryUseRef.ts
+var import_react5 = require("react");
+var tryUseRef = (initialValue) => {
+  try {
+    return (0, import_react5.useRef)(initialValue);
+  } catch {
+    return { current: initialValue };
+  }
+};
+
+// ../lib-react/src/hooks/tryUseState.ts
+var import_react6 = require("react");
+var tryUseState = (initialState) => {
+  try {
+    return (0, import_react6.useState)(initialState);
+  } catch {
+    return [isFunction_default(initialState) ? initialState() : initialState, noop];
+  }
+};
+
+// ../lib-react/src/hooks/useUpdate.ts
+var updateReducer = (num) => (num + 1) % 1e6;
+function useUpdate() {
+  const [, update] = tryUseReducer(updateReducer, 0);
+  return update;
+}
+
+// ../lib-react/src/hooks/tryUseUpdate.ts
+function tryUseUpdate() {
+  try {
+    return useUpdate();
+  } catch {
+    return () => {
+    };
+  }
+}
+
+// src/computed.ts
+var import_reactivity2 = require("@vue/reactivity");
+
+// src/watch.ts
+var import_reactivity = require("@vue/reactivity");
+
+// src/lifecycle.ts
+function onMounted(fn) {
+  tryUseEffect(() => {
+    fn();
+  }, []);
+}
+function onBeforeMount(fn) {
+  const isMounted = tryUseRef(false);
+  if (!isMounted.current) {
+    fn();
+    isMounted.current = true;
+  }
+}
+function onBeforeUnmount(fn) {
+  tryUseEffect(() => {
+    return () => {
+      fn();
+    };
+  }, []);
+}
+function onUnmounted(fn) {
+  onBeforeUnmount(() => setTimeout(fn, 0));
+}
+function onUpdated(fn) {
+  const isMounted = tryUseRef(false);
+  tryUseEffect(() => {
+    isMounted.current ? fn() : isMounted.current = true;
+  });
+}
+function onBeforeUpdate(fn) {
+  tryUseInsertionEffect(fn);
+}
+
+// src/watch.ts
+function watch(source, callback, options = {}) {
+  const handle = tryUseRef();
+  const cancel = tryUseCallback(() => {
+    if (!handle.current)
+      return;
+    handle.current();
+    handle.current = void 0;
+  }, []);
+  const create = tryUseCallback(() => {
+    handle.current && cancel();
+    handle.current = (0, import_reactivity.watch)(
+      source,
+      callback,
+      {
+        ...options,
+        scheduler: (job) => job()
+      }
+    );
+    cancel.pause = handle.current.pause;
+    cancel.resume = handle.current.resume;
+    cancel.stop = handle.current.stop;
+  }, []);
+  !handle.current && create();
+  onMounted(create);
+  onBeforeUnmount(cancel);
+  return cancel;
+}
+
+// src/computed.ts
+function computed(arg1, arg2) {
+  const [ref2] = tryUseState(() => (0, import_reactivity2.computed)(arg1, arg2));
+  watch(ref2, tryUseUpdate());
+  return ref2;
+}
+
+// src/effectScope.ts
+var import_reactivity3 = require("@vue/reactivity");
+var import_react7 = require("react");
+var activeEffectScope;
+function createVueEffectScope(...args) {
+  const scope = (0, import_reactivity3.effectScope)(...args);
+  Reflect.set(scope, "parent", activeEffectScope);
+  if (!args[0] && activeEffectScope) {
+    const scopes = activeEffectScope.scopes || (activeEffectScope.scopes = []);
+    Reflect.set(scope, "index", scopes.push(scope) - 1);
+  }
+  return scope;
+}
+function effectScope(...args) {
+  const hasRun = tryUseRef(false);
+  const [scope] = tryUseState(() => createVueEffectScope(...args));
+  const originalRunRef = tryUseRef(scope.run);
+  const runFn = tryUseCallback((fn) => {
+    if (!hasRun.current) {
+      hasRun.current = true;
+      return originalRunRef.current.bind(scope)(fn);
+    } else {
+      return void 0;
+    }
+  }, []);
+  scope.run = runFn;
+  return scope;
+}
+function withEffectScope(fn, detached) {
+  let currentEffectScope;
+  return (...props) => {
+    const scope = effectScope(detached);
+    const element = (0, import_react7.createElement)(fn, ...props);
+    onBeforeMount(() => {
+      currentEffectScope = activeEffectScope;
+      activeEffectScope = scope;
+    });
+    onMounted(() => activeEffectScope = currentEffectScope);
+    onUnmounted(() => scope.stop());
+    return element;
+  };
+}
+function getCurrentScope() {
+  const [effectScope2] = tryUseState(() => activeEffectScope || (0, import_reactivity3.getCurrentScope)());
+  return effectScope2;
+}
+function onScopeDispose(fn, _failSilently = false) {
+  if (activeEffectScope)
+    Reflect.get(activeEffectScope, "cleanups")?.push(fn);
+}
+
+// src/reactive.ts
+var import_reactivity4 = require("@vue/reactivity");
+var import_react8 = require("react");
+function reactive(target) {
+  const [value] = (0, import_react8.useState)(() => (0, import_reactivity4.reactive)(target));
+  watch(value, tryUseUpdate());
+  return value;
+}
+function shallowReactive(target) {
+  const [value] = (0, import_react8.useState)(() => (0, import_reactivity4.shallowReactive)(target));
+  watch(value, tryUseUpdate());
+  return value;
+}
+
+// src/reactivity.ts
+function reactivity(getter) {
+  watch(() => getter(), tryUseUpdate(), { deep: true });
+  return getter();
+}
+
+// src/readonly.ts
+var import_reactivity5 = require("@vue/reactivity");
+function readonly(target) {
+  const [value] = tryUseState(() => (0, import_reactivity5.readonly)(target));
+  watch(value, tryUseUpdate());
+  return value;
+}
+function shallowReadonly(target) {
+  const [value] = tryUseState(() => (0, import_reactivity5.shallowReadonly)(target));
+  watch(value, tryUseUpdate());
+  return value;
+}
+
+// src/ref.ts
+var import_reactivity6 = require("@vue/reactivity");
+function ref(initValue) {
+  const [ref2] = tryUseState(() => {
+    const r = (0, import_reactivity6.ref)(initValue);
+    Object.defineProperty(r, "current", { set: (value) => r.value = value });
+    return r;
+  });
+  watch(ref2, tryUseUpdate(), { deep: true });
+  return ref2;
+}
+function customRef(factory) {
+  const [ref2] = tryUseState(() => (0, import_reactivity6.customRef)(factory));
+  watch(ref2, tryUseUpdate());
+  return ref2;
+}
+function shallowRef(initValue) {
+  const [ref2] = tryUseState(() => (0, import_reactivity6.shallowRef)(initValue));
+  watch(ref2, tryUseUpdate());
+  return ref2;
+}
+
+// src/watchEffect.ts
+var import_reactivity7 = require("@vue/reactivity");
+function watchEffect(effect, options = {}) {
+  const [watchHandle] = tryUseState(() => (0, import_reactivity7.watch)(effect, null, {
+    ...options,
+    scheduler: (job) => job()
+  }));
+  onBeforeUnmount(() => watchHandle.stop());
+  return watchHandle;
+}
+
+// src/index.ts
+var import_reactivity8 = require("@vue/reactivity");
+var import_react9 = require("react");
+var getCurrentInstance = noop;
+var hasInjectionContext = noop;
+var inject = noop;
+var provide = noop;
+var nextTick = noop;
+var defineComponent = noop;
+var TransitionGroup = noop;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fragment,
+  TransitionGroup,
+  computed,
+  customRef,
+  defineComponent,
+  effectScope,
+  getCurrentInstance,
+  getCurrentScope,
+  h,
+  hasInjectionContext,
+  inject,
+  isProxy,
+  isReactive,
+  isReadonly,
+  isRef,
+  isShallow,
+  markRaw,
+  nextTick,
+  onBeforeMount,
+  onBeforeUnmount,
+  onBeforeUpdate,
+  onMounted,
+  onScopeDispose,
+  onUnmounted,
+  onUpdated,
+  provide,
+  reactive,
+  reactivity,
+  readonly,
+  ref,
+  shallowReactive,
+  shallowReadonly,
+  shallowRef,
+  toRaw,
+  toReactive,
+  toReadonly,
+  toRef,
+  toRefs,
+  toValue,
+  unref,
+  watch,
+  watchEffect,
+  withEffectScope
+});
+/*! Bundled license information:
+
+lodash-es/lodash.js:
+  (**
+   * @license
+   * Lodash (Custom Build) <https://lodash.com/>
+   * Build: `lodash modularize exports="es" -o ./`
+   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+   * Released under MIT license <https://lodash.com/license>
+   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+   *)
+*/