@reause/integrations 0.1.2

package/dist/useChangeCase.iife.js

@@ -0,0 +1,91 @@
+(function(exports, _reause_shared, change_case, react) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region \0rolldown/runtime.js
+	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 __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+	//#endregion
+	change_case = __toESM(change_case, 1);
+	//#region useChangeCase/index.tsx
+	const changeCaseTransforms = /* @__PURE__ */ Object.entries(change_case).filter((entry) => {
+		const [name, fn] = entry;
+		return typeof fn === "function" && name.endsWith("Case");
+	}).reduce((acc, [name, fn]) => {
+		acc[name] = fn;
+		return acc;
+	}, {});
+	/**
+	* React port of VueUse's `useChangeCase`.
+	*
+	* Map from @vueuse/integrations `useChangeCase`
+	* (`source/vueuse/packages/integrations/useChangeCase/`), a reactive wrapper
+	* around the `change-case` package. Upstream returns a writable
+	* `WritableComputedRef<string>`; here the writable computed ref maps to a
+	* `[value, setValue]` tuple: `value` is the transformed string (`change-case`
+	* applied to the internal input state with the current `type`), and
+	* `setValue` updates that internal input state like a controlled `useState`.
+	* `input` is the hook's **read-only value source** and takes a plain `string`
+	* (upstream: `MaybeRef<string>` / `MaybeRefOrGetter<string>`); `type` and
+	* `options` stay `RefOrValue` (format knobs, upstream `MaybeRefOrGetter`) and
+	* are resolved with `toValue` from `@reause/shared`.
+	*
+	* Adjustment for React:
+	* - upstream's writable computed captures a plain `input` once at setup. Here
+	*   a changed `input` prop re-syncs the internal state on the next render, so
+	*   a parent re-render with a new string is reflected; a `setValue` write is
+	*   never clobbered while the `input` prop is unchanged (the baseline records
+	*   the last externally synced value);
+	* - writes are **not** propagated back to the caller: `setValue` updates the
+	*   internal input state only (upstream's writable computed writes through to
+	*   a ref input). A changed `input` prop always wins over the internal state;
+	* - `setValue` writes the RAW string; the transform is re-applied on the next
+	*   render (the upstream computed's `get` re-derives from the ref on access).
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @example
+	* const [changeCase, setChangeCase] = useChangeCase('hello world', 'camelCase')
+	* changeCase // 'helloWorld'
+	* setChangeCase('vue use')
+	* changeCase // 'vueUse'
+	*/
+	function useChangeCase(input, type, options) {
+		const [text, setText] = (0, react.useState)(input);
+		const lastExternalRef = (0, react.useRef)(input);
+		(0, react.useEffect)(() => {
+			if (!Object.is(input, lastExternalRef.current)) {
+				lastExternalRef.current = input;
+				setText(input);
+			}
+		});
+		const typeName = (0, _reause_shared.toValue)(type);
+		const resolvedOptions = (0, _reause_shared.toValue)(options);
+		return [(0, react.useMemo)(() => {
+			const transform = changeCaseTransforms[typeName];
+			if (!transform) throw new Error(`Invalid change case type "${typeName}"`);
+			return transform(text, resolvedOptions);
+		}, [
+			text,
+			typeName,
+			resolvedOptions
+		]), setText];
+	}
+	//#endregion
+	exports.useChangeCase = useChangeCase;
+})(this.reause = this.reause || {}, reause, changeCase, React);

package/dist/useChangeCase.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});var i=Object.create,a=Object.defineProperty,o=Object.getOwnPropertyDescriptor,s=Object.getOwnPropertyNames,c=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,u=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=s(t),c=0,u=i.length,d;c<u;c++)d=i[c],!l.call(e,d)&&d!==n&&a(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=o(t,d))||r.enumerable});return e};n=((e,t,n)=>(n=e==null?{}:i(c(e)),u(t||!e||!e.__esModule||!l.call(e,`default`)?a(n,`default`,{value:e,enumerable:!0}):n,e)))(n,1);let d=Object.entries(n).filter(e=>{let[t,n]=e;return typeof n==`function`&&t.endsWith(`Case`)}).reduce((e,[t,n])=>(e[t]=n,e),{});function f(e,n,i){let[a,o]=(0,r.useState)(e),s=(0,r.useRef)(e);(0,r.useEffect)(()=>{Object.is(e,s.current)||(s.current=e,o(e))});let c=(0,t.toValue)(n),l=(0,t.toValue)(i);return[(0,r.useMemo)(()=>{let e=d[c];if(!e)throw Error(`Invalid change case type "${c}"`);return e(a,l)},[a,c,l]),o]}e.useChangeCase=f})(this.reause=this.reause||{},reause,changeCase,React);

package/dist/useChangeCase.js

@@ -0,0 +1,68 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { toValue } from "@reause/shared";
+import * as changeCase from "change-case";
+//#region useChangeCase/index.tsx
+const changeCaseTransforms = /* @__PURE__ */ Object.entries(changeCase).filter((entry) => {
+	const [name, fn] = entry;
+	return typeof fn === "function" && name.endsWith("Case");
+}).reduce((acc, [name, fn]) => {
+	acc[name] = fn;
+	return acc;
+}, {});
+/**
+* React port of VueUse's `useChangeCase`.
+*
+* Map from @vueuse/integrations `useChangeCase`
+* (`source/vueuse/packages/integrations/useChangeCase/`), a reactive wrapper
+* around the `change-case` package. Upstream returns a writable
+* `WritableComputedRef<string>`; here the writable computed ref maps to a
+* `[value, setValue]` tuple: `value` is the transformed string (`change-case`
+* applied to the internal input state with the current `type`), and
+* `setValue` updates that internal input state like a controlled `useState`.
+* `input` is the hook's **read-only value source** and takes a plain `string`
+* (upstream: `MaybeRef<string>` / `MaybeRefOrGetter<string>`); `type` and
+* `options` stay `RefOrValue` (format knobs, upstream `MaybeRefOrGetter`) and
+* are resolved with `toValue` from `@reause/shared`.
+*
+* Adjustment for React:
+* - upstream's writable computed captures a plain `input` once at setup. Here
+*   a changed `input` prop re-syncs the internal state on the next render, so
+*   a parent re-render with a new string is reflected; a `setValue` write is
+*   never clobbered while the `input` prop is unchanged (the baseline records
+*   the last externally synced value);
+* - writes are **not** propagated back to the caller: `setValue` updates the
+*   internal input state only (upstream's writable computed writes through to
+*   a ref input). A changed `input` prop always wins over the internal state;
+* - `setValue` writes the RAW string; the transform is re-applied on the next
+*   render (the upstream computed's `get` re-derives from the ref on access).
+*
+* @__NO_SIDE_EFFECTS__
+* @example
+* const [changeCase, setChangeCase] = useChangeCase('hello world', 'camelCase')
+* changeCase // 'helloWorld'
+* setChangeCase('vue use')
+* changeCase // 'vueUse'
+*/
+function useChangeCase(input, type, options) {
+	const [text, setText] = useState(input);
+	const lastExternalRef = useRef(input);
+	useEffect(() => {
+		if (!Object.is(input, lastExternalRef.current)) {
+			lastExternalRef.current = input;
+			setText(input);
+		}
+	});
+	const typeName = toValue(type);
+	const resolvedOptions = toValue(options);
+	return [useMemo(() => {
+		const transform = changeCaseTransforms[typeName];
+		if (!transform) throw new Error(`Invalid change case type "${typeName}"`);
+		return transform(text, resolvedOptions);
+	}, [
+		text,
+		typeName,
+		resolvedOptions
+	]), setText];
+}
+//#endregion
+export { useChangeCase };

package/dist/useCookies.d.ts

@@ -0,0 +1,117 @@
+import Cookie from "universal-cookie";
+//#region useCookies/index.d.ts
+type CookieGetOptions = NonNullable<Parameters<Cookie['get']>[1]>;
+type CookieSetOptions = NonNullable<Parameters<Cookie['set']>[2]>;
+type CookieValue = Parameters<Cookie['set']>[1];
+type CookieChangeListener = Parameters<Cookie['addChangeListener']>[0];
+export interface UseCookiesOptions {
+  /**
+   * Do not convert the cookie into an object no matter what
+   *
+   * @default false
+   */
+  doNotParse?: boolean;
+  /**
+   * Automatically add cookie names ever provided to `get` method
+   *
+   * @default false
+   */
+  autoUpdateDependencies?: boolean;
+}
+export interface UseCookiesReturn {
+  /**
+   * Reactive get cookie by name. If **autoUpdateDependencies = true** then it
+   * will update watching dependencies
+   */
+  get: <T = any>(name: string, options?: CookieGetOptions) => T;
+  /**
+   * Reactive get all cookies
+   */
+  getAll: <T = any>(options?: CookieGetOptions) => T;
+  /**
+   * Set cookie
+   *
+   * @see https://www.npmjs.com/package/universal-cookie#setname-value-options
+   */
+  set: (name: string, value: CookieValue, options?: CookieSetOptions) => void;
+  /**
+   * Remove cookie
+   *
+   * @see https://www.npmjs.com/package/universal-cookie#removename-options
+   */
+  remove: (name: string, options?: CookieSetOptions) => void;
+  /**
+   * Add a listener fired on every cookie change
+   */
+  addChangeListener: (callback: CookieChangeListener) => void;
+  /**
+   * Remove a previously added change listener
+   */
+  removeChangeListener: (callback: CookieChangeListener) => void;
+}
+/**
+ * Minimal structural request object accepted by {@link createCookies} for SSR.
+ *
+ * Deviation from upstream: VueUse types this parameter as Node's
+ * `IncomingMessage` (`import type { IncomingMessage } from 'node:http'`), which
+ * would pull the Node built-in into a browser bundle. Only `headers.cookie` is
+ * actually read, so the port declares that shape itself and keeps the browser
+ * build free of any `node:` import.
+ */
+export interface CreateCookiesRequest {
+  headers?: {
+    cookie?: string | null;
+  };
+}
+/**
+ * React port of VueUse's `createCookies` — creates a `universal-cookie`
+ * instance from a request (default is `window.document.cookie`) and returns a
+ * {@link useCookies} bound to that instance.
+ *
+ * Map from @vueuse/integrations `createCookies`
+ * (`source/vueuse/packages/integrations/useCookies/index.ts`).
+ *
+ * @param req - incoming request (for SSR); a plain `cookie` header string is
+ * also accepted for convenience
+ * @see https://github.com/reactivestack/cookies/tree/master/packages/universal-cookie universal-cookie
+ *
+ * @__NO_SIDE_EFFECTS__
+ * @example
+ * const useSsrCookies = createCookies({ headers: { cookie: 'locale=en-US' } })
+ * const { get } = useSsrCookies(['locale'])
+ * get('locale') // 'en-US'
+ */
+export declare function createCookies(req?: CreateCookiesRequest | string): (dependencies?: string[] | null, options?: UseCookiesOptions) => UseCookiesReturn;
+/**
+ * React port of VueUse's `useCookies` — reactive methods to work with cookies
+ * (use {@link createCookies} instead if you are using SSR).
+ *
+ * Map from @vueuse/integrations `useCookies`
+ * (`source/vueuse/packages/integrations/useCookies/index.ts`).
+ *
+ * Adjustment for React:
+ * - upstream returns a **method object** (`get`, `getAll`, `set`, `remove`,
+ *   `addChangeListener`, `removeChangeListener`), not a piece of writable
+ *   state, so the port returns the same object instead of a tuple (§2B);
+ * - upstream's `shallowRef(0)` "touches" counter is a `useState` counter read
+ *   in the render body, so a watched cookie change re-renders the component
+ *   and the `get`/`getAll` closures from that render observe the new value;
+ * - `previousCookies` and the mutable watch list live in refs so they persist
+ *   across renders exactly as upstream's local variables do;
+ * - upstream's `tryOnScopeDispose` maps to a `useEffect` cleanup that removes
+ *   the change listener.
+ *
+ * @param dependencies - array of watching cookie's names. Pass empty array if don't want to watch cookies changes.
+ * @param options
+ * @param options.doNotParse - don't try parse value as JSON
+ * @param options.autoUpdateDependencies - automatically update watching dependencies
+ * @param cookies - universal-cookie instance
+ *
+ * @__NO_SIDE_EFFECTS__
+ * @example
+ * const { get, set } = useCookies(['locale'])
+ * get('locale') // reads reactively
+ * set('locale', 'en-US')
+ */
+export declare function useCookies(dependencies?: string[] | null, { doNotParse, autoUpdateDependencies }?: UseCookiesOptions, cookies?: Cookie): UseCookiesReturn;
+//#endregion

package/dist/useCookies.iife.js

@@ -0,0 +1,142 @@
+(function(exports, react, universal_cookie) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region \0rolldown/runtime.js
+	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 __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+	//#endregion
+	universal_cookie = __toESM(universal_cookie, 1);
+	//#region useCookies/index.tsx
+	/**
+	* React port of VueUse's `createCookies` — creates a `universal-cookie`
+	* instance from a request (default is `window.document.cookie`) and returns a
+	* {@link useCookies} bound to that instance.
+	*
+	* Map from @vueuse/integrations `createCookies`
+	* (`source/vueuse/packages/integrations/useCookies/index.ts`).
+	*
+	* @param req - incoming request (for SSR); a plain `cookie` header string is
+	* also accepted for convenience
+	* @see https://github.com/reactivestack/cookies/tree/master/packages/universal-cookie universal-cookie
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @example
+	* const useSsrCookies = createCookies({ headers: { cookie: 'locale=en-US' } })
+	* const { get } = useSsrCookies(['locale'])
+	* get('locale') // 'en-US'
+	*/
+	function createCookies(req) {
+		var _req$headers$cookie, _req$headers;
+		const universalCookie = new universal_cookie.default(typeof req === "string" ? req : (_req$headers$cookie = req === null || req === void 0 || (_req$headers = req.headers) === null || _req$headers === void 0 ? void 0 : _req$headers.cookie) !== null && _req$headers$cookie !== void 0 ? _req$headers$cookie : null);
+		return (dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}) => useCookies(dependencies, {
+			doNotParse,
+			autoUpdateDependencies
+		}, universalCookie);
+	}
+	/**
+	* React port of VueUse's `useCookies` — reactive methods to work with cookies
+	* (use {@link createCookies} instead if you are using SSR).
+	*
+	* Map from @vueuse/integrations `useCookies`
+	* (`source/vueuse/packages/integrations/useCookies/index.ts`).
+	*
+	* Adjustment for React:
+	* - upstream returns a **method object** (`get`, `getAll`, `set`, `remove`,
+	*   `addChangeListener`, `removeChangeListener`), not a piece of writable
+	*   state, so the port returns the same object instead of a tuple (§2B);
+	* - upstream's `shallowRef(0)` "touches" counter is a `useState` counter read
+	*   in the render body, so a watched cookie change re-renders the component
+	*   and the `get`/`getAll` closures from that render observe the new value;
+	* - `previousCookies` and the mutable watch list live in refs so they persist
+	*   across renders exactly as upstream's local variables do;
+	* - upstream's `tryOnScopeDispose` maps to a `useEffect` cleanup that removes
+	*   the change listener.
+	*
+	* @param dependencies - array of watching cookie's names. Pass empty array if don't want to watch cookies changes.
+	* @param options
+	* @param options.doNotParse - don't try parse value as JSON
+	* @param options.autoUpdateDependencies - automatically update watching dependencies
+	* @param cookies - universal-cookie instance
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @example
+	* const { get, set } = useCookies(['locale'])
+	* get('locale') // reads reactively
+	* set('locale', 'en-US')
+	*/
+	function useCookies(dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}, cookies = new universal_cookie.default()) {
+		const watchingDependenciesRef = (0, react.useRef)(autoUpdateDependencies ? [...dependencies || []] : dependencies);
+		const previousCookiesRef = (0, react.useRef)(null);
+		if (previousCookiesRef.current === null) previousCookiesRef.current = cookies.getAll({ doNotParse: true });
+		const [touches, setTouches] = (0, react.useState)(0);
+		const previousDependenciesRef = (0, react.useRef)(dependencies);
+		(0, react.useEffect)(() => {
+			if (previousDependenciesRef.current === dependencies) return;
+			previousDependenciesRef.current = dependencies;
+			if (!autoUpdateDependencies) watchingDependenciesRef.current = dependencies;
+		}, [dependencies, autoUpdateDependencies]);
+		const onChange = (0, react.useCallback)(() => {
+			var _watchingDependencies;
+			const newCookies = cookies.getAll({ doNotParse: true });
+			const previous = previousCookiesRef.current;
+			if (previous === null) {
+				previousCookiesRef.current = newCookies;
+				return;
+			}
+			if (shouldUpdate((_watchingDependencies = watchingDependenciesRef.current) !== null && _watchingDependencies !== void 0 ? _watchingDependencies : null, newCookies, previous)) setTouches((n) => n + 1);
+			previousCookiesRef.current = newCookies;
+		}, [cookies]);
+		(0, react.useEffect)(() => {
+			cookies.addChangeListener(onChange);
+			return () => {
+				cookies.removeChangeListener(onChange);
+			};
+		}, [cookies, onChange]);
+		return {
+			get: (name, options) => {
+				const watchingDependencies = watchingDependenciesRef.current;
+				/**
+				* Auto update watching dependencies if needed
+				*/
+				if (autoUpdateDependencies && watchingDependencies && !watchingDependencies.includes(name)) watchingDependencies.push(name);
+				return cookies.get(name, {
+					doNotParse,
+					...options
+				});
+			},
+			getAll: (options) => cookies.getAll({
+				doNotParse,
+				...options
+			}),
+			set: (name, value, options) => cookies.set(name, value, options),
+			remove: (name, options) => cookies.remove(name, options),
+			addChangeListener: (callback) => cookies.addChangeListener(callback),
+			removeChangeListener: (callback) => cookies.removeChangeListener(callback)
+		};
+	}
+	function shouldUpdate(dependencies, newCookies, oldCookies) {
+		if (!dependencies) return true;
+		for (const dependency of dependencies) if (newCookies[dependency] !== oldCookies[dependency]) return true;
+		return false;
+	}
+	//#endregion
+	exports.createCookies = createCookies;
+	exports.useCookies = useCookies;
+})(this.reause = this.reause || {}, React, UniversalCookie);

package/dist/useCookies.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});var r=Object.create,i=Object.defineProperty,a=Object.getOwnPropertyDescriptor,o=Object.getOwnPropertyNames,s=Object.getPrototypeOf,c=Object.prototype.hasOwnProperty,l=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var s=o(t),l=0,u=s.length,d;l<u;l++)d=s[l],!c.call(e,d)&&d!==n&&i(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=a(t,d))||r.enumerable});return e};n=((e,t,n)=>(n=e==null?{}:r(s(e)),l(t||!e||!e.__esModule||!c.call(e,`default`)?i(n,`default`,{value:e,enumerable:!0}):n,e)))(n,1);function u(e){var t,r;let i=new n.default(typeof e==`string`?e:(t=e==null||(r=e.headers)==null?void 0:r.cookie)==null?null:t);return(e,{doNotParse:t=!1,autoUpdateDependencies:n=!1}={})=>d(e,{doNotParse:t,autoUpdateDependencies:n},i)}function d(e,{doNotParse:r=!1,autoUpdateDependencies:i=!1}={},a=new n.default){let o=(0,t.useRef)(i?[...e||[]]:e),s=(0,t.useRef)(null);s.current===null&&(s.current=a.getAll({doNotParse:!0}));let[c,l]=(0,t.useState)(0),u=(0,t.useRef)(e);(0,t.useEffect)(()=>{u.current!==e&&(u.current=e,i||(o.current=e))},[e,i]);let d=(0,t.useCallback)(()=>{var e;let t=a.getAll({doNotParse:!0}),n=s.current;if(n===null){s.current=t;return}f((e=o.current)==null?null:e,t,n)&&l(e=>e+1),s.current=t},[a]);return(0,t.useEffect)(()=>(a.addChangeListener(d),()=>{a.removeChangeListener(d)}),[a,d]),{get:(e,t)=>{let n=o.current;return i&&n&&!n.includes(e)&&n.push(e),a.get(e,{doNotParse:r,...t})},getAll:e=>a.getAll({doNotParse:r,...e}),set:(e,t,n)=>a.set(e,t,n),remove:(e,t)=>a.remove(e,t),addChangeListener:e=>a.addChangeListener(e),removeChangeListener:e=>a.removeChangeListener(e)}}function f(e,t,n){if(!e)return!0;for(let r of e)if(t[r]!==n[r])return!0;return!1}e.createCookies=u,e.useCookies=d})(this.reause=this.reause||{},React,UniversalCookie);

package/dist/useCookies.js

@@ -0,0 +1,117 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import Cookie from "universal-cookie";
+//#region useCookies/index.tsx
+/**
+* React port of VueUse's `createCookies` — creates a `universal-cookie`
+* instance from a request (default is `window.document.cookie`) and returns a
+* {@link useCookies} bound to that instance.
+*
+* Map from @vueuse/integrations `createCookies`
+* (`source/vueuse/packages/integrations/useCookies/index.ts`).
+*
+* @param req - incoming request (for SSR); a plain `cookie` header string is
+* also accepted for convenience
+* @see https://github.com/reactivestack/cookies/tree/master/packages/universal-cookie universal-cookie
+*
+* @__NO_SIDE_EFFECTS__
+* @example
+* const useSsrCookies = createCookies({ headers: { cookie: 'locale=en-US' } })
+* const { get } = useSsrCookies(['locale'])
+* get('locale') // 'en-US'
+*/
+function createCookies(req) {
+	var _req$headers$cookie, _req$headers;
+	const universalCookie = new Cookie(typeof req === "string" ? req : (_req$headers$cookie = req === null || req === void 0 || (_req$headers = req.headers) === null || _req$headers === void 0 ? void 0 : _req$headers.cookie) !== null && _req$headers$cookie !== void 0 ? _req$headers$cookie : null);
+	return (dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}) => useCookies(dependencies, {
+		doNotParse,
+		autoUpdateDependencies
+	}, universalCookie);
+}
+/**
+* React port of VueUse's `useCookies` — reactive methods to work with cookies
+* (use {@link createCookies} instead if you are using SSR).
+*
+* Map from @vueuse/integrations `useCookies`
+* (`source/vueuse/packages/integrations/useCookies/index.ts`).
+*
+* Adjustment for React:
+* - upstream returns a **method object** (`get`, `getAll`, `set`, `remove`,
+*   `addChangeListener`, `removeChangeListener`), not a piece of writable
+*   state, so the port returns the same object instead of a tuple (§2B);
+* - upstream's `shallowRef(0)` "touches" counter is a `useState` counter read
+*   in the render body, so a watched cookie change re-renders the component
+*   and the `get`/`getAll` closures from that render observe the new value;
+* - `previousCookies` and the mutable watch list live in refs so they persist
+*   across renders exactly as upstream's local variables do;
+* - upstream's `tryOnScopeDispose` maps to a `useEffect` cleanup that removes
+*   the change listener.
+*
+* @param dependencies - array of watching cookie's names. Pass empty array if don't want to watch cookies changes.
+* @param options
+* @param options.doNotParse - don't try parse value as JSON
+* @param options.autoUpdateDependencies - automatically update watching dependencies
+* @param cookies - universal-cookie instance
+*
+* @__NO_SIDE_EFFECTS__
+* @example
+* const { get, set } = useCookies(['locale'])
+* get('locale') // reads reactively
+* set('locale', 'en-US')
+*/
+function useCookies(dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}, cookies = new Cookie()) {
+	const watchingDependenciesRef = useRef(autoUpdateDependencies ? [...dependencies || []] : dependencies);
+	const previousCookiesRef = useRef(null);
+	if (previousCookiesRef.current === null) previousCookiesRef.current = cookies.getAll({ doNotParse: true });
+	const [touches, setTouches] = useState(0);
+	const previousDependenciesRef = useRef(dependencies);
+	useEffect(() => {
+		if (previousDependenciesRef.current === dependencies) return;
+		previousDependenciesRef.current = dependencies;
+		if (!autoUpdateDependencies) watchingDependenciesRef.current = dependencies;
+	}, [dependencies, autoUpdateDependencies]);
+	const onChange = useCallback(() => {
+		var _watchingDependencies;
+		const newCookies = cookies.getAll({ doNotParse: true });
+		const previous = previousCookiesRef.current;
+		if (previous === null) {
+			previousCookiesRef.current = newCookies;
+			return;
+		}
+		if (shouldUpdate((_watchingDependencies = watchingDependenciesRef.current) !== null && _watchingDependencies !== void 0 ? _watchingDependencies : null, newCookies, previous)) setTouches((n) => n + 1);
+		previousCookiesRef.current = newCookies;
+	}, [cookies]);
+	useEffect(() => {
+		cookies.addChangeListener(onChange);
+		return () => {
+			cookies.removeChangeListener(onChange);
+		};
+	}, [cookies, onChange]);
+	return {
+		get: (name, options) => {
+			const watchingDependencies = watchingDependenciesRef.current;
+			/**
+			* Auto update watching dependencies if needed
+			*/
+			if (autoUpdateDependencies && watchingDependencies && !watchingDependencies.includes(name)) watchingDependencies.push(name);
+			return cookies.get(name, {
+				doNotParse,
+				...options
+			});
+		},
+		getAll: (options) => cookies.getAll({
+			doNotParse,
+			...options
+		}),
+		set: (name, value, options) => cookies.set(name, value, options),
+		remove: (name, options) => cookies.remove(name, options),
+		addChangeListener: (callback) => cookies.addChangeListener(callback),
+		removeChangeListener: (callback) => cookies.removeChangeListener(callback)
+	};
+}
+function shouldUpdate(dependencies, newCookies, oldCookies) {
+	if (!dependencies) return true;
+	for (const dependency of dependencies) if (newCookies[dependency] !== oldCookies[dependency]) return true;
+	return false;
+}
+//#endregion
+export { createCookies, useCookies };