@conorroberts/utils 0.0.58 → 0.0.60

package/dist/oxlint/no-type-cast.mjs

@@ -1,45 +0,0 @@
-import { defineRule } from "oxlint";
-
-//#region src/oxlint-plugins/no-type-cast.js
-/** @typedef {import("oxlint").ESTree.Node} ESTNode */
-const rule = defineRule({
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow TypeScript type assertions (`as` and angle-bracket syntax) to prevent unsafe type casting.",
-			recommended: false
-		},
-		schema: []
-	},
-	createOnce(context) {
-		return {
-			TSAsExpression(rawNode) {
-				if (rawNode.type !== "TSAsExpression") return;
-				if (rawNode.typeAnnotation.type === "TSTypeReference" && rawNode.typeAnnotation.typeName.type === "Identifier" && rawNode.typeAnnotation.typeName.name === "const") return;
-				context.report({
-					node: rawNode,
-					message: "Type casting with `as` is not permitted. Use runtime validation with valibot or refactor to avoid type casting."
-				});
-			},
-			TSTypeAssertion(rawNode) {
-				if (rawNode.type !== "TSTypeAssertion") return;
-				context.report({
-					node: rawNode,
-					message: "Type casting with angle brackets `<Type>` is not permitted. Use runtime validation with valibot or refactor to avoid type casting."
-				});
-			},
-			TSNonNullExpression(rawNode) {
-				if (rawNode.type !== "TSNonNullExpression") return;
-				context.report({
-					node: rawNode,
-					message: "Non-null assertion operator `!` is not permitted. Handle null/undefined cases explicitly or use optional chaining."
-				});
-			}
-		};
-	}
-});
-const noTypeCastRule = rule;
-
-//#endregion
-export { noTypeCastRule };
-//# sourceMappingURL=no-type-cast.mjs.map

package/dist/oxlint/no-type-cast.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"no-type-cast.mjs","names":[],"sources":["../../src/oxlint-plugins/no-type-cast.js"],"sourcesContent":["import { defineRule } from \"oxlint\";\n\n/** @typedef {import(\"oxlint\").ESTree.Node} ESTNode */\n\nconst rule = defineRule({\n  meta: {\n    type: \"problem\",\n    docs: {\n      description:\n        \"Disallow TypeScript type assertions (`as` and angle-bracket syntax) to prevent unsafe type casting.\",\n      recommended: false,\n    },\n    schema: [],\n  },\n\n  createOnce(context) {\n    return /** @type {import(\"oxlint\").VisitorWithHooks} */ ({\n      /**\n       * @param {ESTNode} rawNode\n       */\n      TSAsExpression(rawNode) {\n        if (rawNode.type !== \"TSAsExpression\") return;\n\n        // Allow \"as const\" assertions\n        if (\n          rawNode.typeAnnotation.type === \"TSTypeReference\" &&\n          rawNode.typeAnnotation.typeName.type === \"Identifier\" &&\n          rawNode.typeAnnotation.typeName.name === \"const\"\n        ) {\n          return;\n        }\n\n        context.report({\n          node: rawNode,\n          message:\n            \"Type casting with `as` is not permitted. Use runtime validation with valibot or refactor to avoid type casting.\",\n        });\n      },\n\n      /**\n       * @param {ESTNode} rawNode\n       */\n      TSTypeAssertion(rawNode) {\n        if (rawNode.type !== \"TSTypeAssertion\") return;\n\n        context.report({\n          node: rawNode,\n          message:\n            \"Type casting with angle brackets `<Type>` is not permitted. Use runtime validation with valibot or refactor to avoid type casting.\",\n        });\n      },\n\n      /**\n       * @param {ESTNode} rawNode\n       */\n      TSNonNullExpression(rawNode) {\n        if (rawNode.type !== \"TSNonNullExpression\") return;\n\n        context.report({\n          node: rawNode,\n          message:\n            \"Non-null assertion operator `!` is not permitted. Handle null/undefined cases explicitly or use optional chaining.\",\n        });\n      },\n    });\n  },\n});\n\nexport const noTypeCastRule = rule;\n\n"],"mappings":";;;;AAIA,MAAM,OAAO,WAAW;CACtB,MAAM;EACJ,MAAM;EACN,MAAM;GACJ,aACE;GACF,aAAa;GACd;EACD,QAAQ,EAAE;EACX;CAED,WAAW,SAAS;AAClB,SAAyD;GAIvD,eAAe,SAAS;AACtB,QAAI,QAAQ,SAAS,iBAAkB;AAGvC,QACE,QAAQ,eAAe,SAAS,qBAChC,QAAQ,eAAe,SAAS,SAAS,gBACzC,QAAQ,eAAe,SAAS,SAAS,QAEzC;AAGF,YAAQ,OAAO;KACb,MAAM;KACN,SACE;KACH,CAAC;;GAMJ,gBAAgB,SAAS;AACvB,QAAI,QAAQ,SAAS,kBAAmB;AAExC,YAAQ,OAAO;KACb,MAAM;KACN,SACE;KACH,CAAC;;GAMJ,oBAAoB,SAAS;AAC3B,QAAI,QAAQ,SAAS,sBAAuB;AAE5C,YAAQ,OAAO;KACb,MAAM;KACN,SACE;KACH,CAAC;;GAEL;;CAEJ,CAAC;AAEF,MAAa,iBAAiB"}

package/dist/oxlint/pretty-props.d.mts

@@ -1,11 +0,0 @@
-import * as oxlint6 from "oxlint";
-
-//#region src/oxlint-plugins/pretty-props.d.ts
-declare const prettyPropsRule: oxlint6.Rule;
-type RuleContext = oxlint6.Context;
-type ESTNode = oxlint6.ESTree.Node;
-type ESTExpression = oxlint6.ESTree.Expression;
-type FunctionLikeNode = oxlint6.ESTree.Function | oxlint6.ESTree.ArrowFunctionExpression;
-//#endregion
-export { ESTExpression, ESTNode, FunctionLikeNode, RuleContext, prettyPropsRule };
-//# sourceMappingURL=pretty-props.d.mts.map

package/dist/oxlint/pretty-props.mjs

@@ -1,127 +0,0 @@
-import { defineRule } from "oxlint";
-
-//#region src/oxlint-plugins/pretty-props.js
-/**
-* @typedef {import("oxlint").Context} RuleContext
-* @typedef {import("oxlint").ESTree.Node} ESTNode
-* @typedef {import("oxlint").ESTree.Expression} ESTExpression
-* @typedef {import("oxlint").ESTree.Function | import("oxlint").ESTree.ArrowFunctionExpression} FunctionLikeNode
-*/
-const JSX_NODE_TYPES = new Set(["JSXElement", "JSXFragment"]);
-const FUNCTION_NODE_TYPES = new Set([
-	"FunctionDeclaration",
-	"FunctionExpression",
-	"ArrowFunctionExpression"
-]);
-/**
-* @param {unknown} node
-* @returns {node is ESTNode & { type: string }}
-*/
-const isNode = (node) => Boolean(node && typeof node === "object" && "type" in node);
-/**
-* @param {unknown} node
-* @returns {node is FunctionLikeNode}
-*/
-const isFunctionLike = (node) => isNode(node) && FUNCTION_NODE_TYPES.has(node.type);
-/**
-* Check if an expression contains JSX
-* @param {ESTExpression | null | undefined} root
-*/
-const expressionContainsJsx = (root) => {
-	if (!root || !isNode(root)) return false;
-	const stack = [root];
-	while (stack.length > 0) {
-		const current = stack.pop();
-		if (!current || !isNode(current)) continue;
-		if (JSX_NODE_TYPES.has(current.type)) return true;
-		if (FUNCTION_NODE_TYPES.has(current.type) && current !== root) continue;
-		for (const key of Object.keys(current)) {
-			if (key === "parent") continue;
-			const value = current[key];
-			if (!value) continue;
-			if (Array.isArray(value)) {
-				for (const element of value) if (isNode(element)) stack.push(element);
-			} else if (isNode(value)) stack.push(value);
-		}
-	}
-	return false;
-};
-/**
-* Check if a function returns JSX
-* @param {FunctionLikeNode} node
-*/
-const functionReturnsJsx = (node) => {
-	if (node.type === "ArrowFunctionExpression" && node.body && node.body.type !== "BlockStatement") return expressionContainsJsx(node.body);
-	const body = node.body;
-	if (!body || body.type !== "BlockStatement") return false;
-	const stack = [body];
-	while (stack.length > 0) {
-		const current = stack.pop();
-		if (!current || !isNode(current)) continue;
-		if (current.type === "ReturnStatement") {
-			const argument = current.argument;
-			if (argument && expressionContainsJsx(argument)) return true;
-		}
-		if (FUNCTION_NODE_TYPES.has(current.type) && current !== body) continue;
-		for (const key of Object.keys(current)) {
-			if (key === "parent") continue;
-			const value = current[key];
-			if (!value) continue;
-			if (Array.isArray(value)) {
-				for (const element of value) if (isNode(element)) stack.push(element);
-			} else if (isNode(value)) stack.push(value);
-		}
-	}
-	return false;
-};
-const rule = defineRule({
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Enforce consistent props parameter naming and disallow destructuring in component parameters.",
-			recommended: false
-		},
-		schema: []
-	},
-	createOnce(context) {
-		/**
-		* @param {FunctionLikeNode} node
-		*/
-		const checkFunction = (node) => {
-			if (!functionReturnsJsx(node)) return;
-			const params = node.params;
-			if (!params || params.length === 0) return;
-			const firstParam = params[0];
-			if (!firstParam || !isNode(firstParam)) return;
-			if (firstParam.type === "ObjectPattern" || firstParam.type === "ArrayPattern") {
-				context.report({
-					node: firstParam,
-					message: "Props should not be destructured in the component parameter. Use 'props' instead and destructure inside the component body."
-				});
-				return;
-			}
-			if (firstParam.type === "Identifier") {
-				if (firstParam.name !== "props") context.report({
-					node: firstParam,
-					message: `Props parameter should be named 'props', not '${firstParam.name}'.`
-				});
-			}
-		};
-		return {
-			FunctionDeclaration(node) {
-				if (isFunctionLike(node)) checkFunction(node);
-			},
-			FunctionExpression(node) {
-				if (isFunctionLike(node)) checkFunction(node);
-			},
-			ArrowFunctionExpression(node) {
-				if (isFunctionLike(node)) checkFunction(node);
-			}
-		};
-	}
-});
-const prettyPropsRule = rule;
-
-//#endregion
-export { prettyPropsRule };
-//# sourceMappingURL=pretty-props.mjs.map

package/dist/oxlint/pretty-props.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"pretty-props.mjs","names":[],"sources":["../../src/oxlint-plugins/pretty-props.js"],"sourcesContent":["import { defineRule } from \"oxlint\";\n\n/**\n * @typedef {import(\"oxlint\").Context} RuleContext\n * @typedef {import(\"oxlint\").ESTree.Node} ESTNode\n * @typedef {import(\"oxlint\").ESTree.Expression} ESTExpression\n * @typedef {import(\"oxlint\").ESTree.Function | import(\"oxlint\").ESTree.ArrowFunctionExpression} FunctionLikeNode\n */\n\nconst JSX_NODE_TYPES = new Set([\"JSXElement\", \"JSXFragment\"]);\nconst FUNCTION_NODE_TYPES = new Set([\"FunctionDeclaration\", \"FunctionExpression\", \"ArrowFunctionExpression\"]);\n\n/**\n * @param {unknown} node\n * @returns {node is ESTNode & { type: string }}\n */\nconst isNode = (node) => Boolean(node && typeof node === \"object\" && \"type\" in node);\n\n/**\n * @param {unknown} node\n * @returns {node is FunctionLikeNode}\n */\nconst isFunctionLike = (node) => isNode(node) && FUNCTION_NODE_TYPES.has(node.type);\n\n/**\n * Check if an expression contains JSX\n * @param {ESTExpression | null | undefined} root\n */\nconst expressionContainsJsx = (root) => {\n  if (!root || !isNode(root)) return false;\n\n  const stack = [root];\n\n  while (stack.length > 0) {\n    const current = stack.pop();\n    if (!current || !isNode(current)) continue;\n\n    if (JSX_NODE_TYPES.has(current.type)) {\n      return true;\n    }\n\n    if (FUNCTION_NODE_TYPES.has(current.type) && current !== root) {\n      continue;\n    }\n\n    for (const key of Object.keys(current)) {\n      if (key === \"parent\") continue;\n\n      const value = current[key];\n      if (!value) continue;\n\n      if (Array.isArray(value)) {\n        for (const element of value) {\n          if (isNode(element)) {\n            stack.push(element);\n          }\n        }\n      } else if (isNode(value)) {\n        stack.push(value);\n      }\n    }\n  }\n\n  return false;\n};\n\n/**\n * Check if a function returns JSX\n * @param {FunctionLikeNode} node\n */\nconst functionReturnsJsx = (node) => {\n  // Check arrow functions with expression body\n  if (node.type === \"ArrowFunctionExpression\" && node.body && node.body.type !== \"BlockStatement\") {\n    return expressionContainsJsx(node.body);\n  }\n\n  // Check for return statements in function body\n  const body = node.body;\n  if (!body || body.type !== \"BlockStatement\") return false;\n\n  const stack = [body];\n  while (stack.length > 0) {\n    const current = stack.pop();\n    if (!current || !isNode(current)) continue;\n\n    if (current.type === \"ReturnStatement\") {\n      const argument = current.argument;\n      if (argument && expressionContainsJsx(argument)) {\n        return true;\n      }\n    }\n\n    // Don't traverse into nested functions\n    if (FUNCTION_NODE_TYPES.has(current.type) && current !== body) {\n      continue;\n    }\n\n    for (const key of Object.keys(current)) {\n      if (key === \"parent\") continue;\n\n      const value = current[key];\n      if (!value) continue;\n\n      if (Array.isArray(value)) {\n        for (const element of value) {\n          if (isNode(element)) {\n            stack.push(element);\n          }\n        }\n      } else if (isNode(value)) {\n        stack.push(value);\n      }\n    }\n  }\n\n  return false;\n};\n\nconst rule = defineRule({\n  meta: {\n    type: \"problem\",\n    docs: {\n      description: \"Enforce consistent props parameter naming and disallow destructuring in component parameters.\",\n      recommended: false,\n    },\n    schema: [],\n  },\n\n  createOnce(context) {\n    /**\n     * @param {FunctionLikeNode} node\n     */\n    const checkFunction = (node) => {\n      // Only check functions that return JSX (React components)\n      if (!functionReturnsJsx(node)) {\n        return;\n      }\n\n      const params = node.params;\n      if (!params || params.length === 0) {\n        return;\n      }\n\n      const firstParam = params[0];\n      if (!firstParam || !isNode(firstParam)) {\n        return;\n      }\n\n      // Check if the first parameter is destructured\n      if (firstParam.type === \"ObjectPattern\" || firstParam.type === \"ArrayPattern\") {\n        context.report({\n          node: firstParam,\n          message:\n            \"Props should not be destructured in the component parameter. Use 'props' instead and destructure inside the component body.\",\n        });\n        return;\n      }\n\n      // Check if the first parameter is an Identifier and is named 'props'\n      if (firstParam.type === \"Identifier\") {\n        if (firstParam.name !== \"props\") {\n          context.report({\n            node: firstParam,\n            message: `Props parameter should be named 'props', not '${firstParam.name}'.`,\n          });\n        }\n      }\n    };\n\n    return /** @type {import(\"oxlint\").VisitorWithHooks} */ ({\n      FunctionDeclaration(node) {\n        if (isFunctionLike(node)) checkFunction(node);\n      },\n      FunctionExpression(node) {\n        if (isFunctionLike(node)) checkFunction(node);\n      },\n      ArrowFunctionExpression(node) {\n        if (isFunctionLike(node)) checkFunction(node);\n      },\n    });\n  },\n});\n\nexport const prettyPropsRule = rule;\n\n"],"mappings":"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"}

package/dist/react.d.mts

@@ -1,73 +0,0 @@
-//#region src/react/useStableCallback.d.ts
-type AnyFunction = (...args: any[]) => any;
-/**
- * Creates a stable callback that always calls the latest version of the function.
- * Useful for callbacks that need to be used in dependency arrays but should always
- * execute the most recent version of the callback.
- */
-declare const useStableCallback: <T extends AnyFunction>(callback: T) => T;
-//#endregion
-//#region src/react/useOnce.d.ts
-/**
- * Runs a callback only once when a condition becomes truthy.
- * The callback is stabilized internally to always reference the latest version.
- *
- * @param condition - When truthy (evaluated via Boolean()), the callback will be executed (only once).
- * @param callback - The function to run once when the condition is met.
- *
- * @example
- * ```tsx
- * const isReady = true;
- * useOnce(isReady, () => {
- *   console.log("Ready!");
- * });
- * ```
- */
-declare const useOnce: (condition: unknown, callback: () => void) => void;
-//#endregion
-//#region src/react/useLocalOnce.d.ts
-/**
- * Runs a callback only once when a condition becomes truthy, executing synchronously
- * during render. The callback is stabilized internally to always reference the latest version.
- *
- * Unlike `useOnce`, this runs at the top level of the hook (not in useEffect),
- * making it suitable for state updates that need to happen synchronously during render.
- *
- * @param condition - When truthy (evaluated via Boolean()), the callback will be executed (only once).
- * @param callback - The function to run once when the condition is met.
- *
- * @example
- * ```tsx
- * const user: User | null = getUser();
- * useLocalOnce(user, () => {
- *   setState(user.name);
- * });
- * ```
- */
-declare const useLocalOnce: (condition: unknown, callback: () => void) => void;
-//#endregion
-//#region src/react/useOnMount.d.ts
-/**
- * Calls the given callback when the component mounts.
- * Uses useStableCallback internally to ensure the latest version is called.
- *
- * @param callback - The function to run when the component mounts.
- *
- * @example
- * ```tsx
- * useOnMount(() => {
- *   console.log("Component mounted!");
- * });
- * ```
- */
-declare const useOnMount: (callback: () => void) => void;
-//#endregion
-//#region src/react/useOnUnmount.d.ts
-/**
- * Calls the given callback when the component unmounts.
- * Uses useStableCallback internally to ensure the latest version is called.
- */
-declare const useOnUnmount: (callback: () => void) => void;
-//#endregion
-export { useLocalOnce, useOnMount, useOnUnmount, useOnce, useStableCallback };
-//# sourceMappingURL=react.d.mts.map

package/dist/react.mjs

@@ -1,113 +0,0 @@
-import { useCallback, useEffect, useRef } from "react";
-
-//#region src/react/useStableCallback.ts
-/**
-* Creates a stable callback that always calls the latest version of the function.
-* Useful for callbacks that need to be used in dependency arrays but should always
-* execute the most recent version of the callback.
-*/
-const useStableCallback = (callback) => {
-	const callbackRef = useRef(callback);
-	callbackRef.current = callback;
-	return useCallback((...args) => {
-		return callbackRef.current(...args);
-	}, []);
-};
-
-//#endregion
-//#region src/react/useOnce.ts
-/**
-* Runs a callback only once when a condition becomes truthy.
-* The callback is stabilized internally to always reference the latest version.
-*
-* @param condition - When truthy (evaluated via Boolean()), the callback will be executed (only once).
-* @param callback - The function to run once when the condition is met.
-*
-* @example
-* ```tsx
-* const isReady = true;
-* useOnce(isReady, () => {
-*   console.log("Ready!");
-* });
-* ```
-*/
-const useOnce = (condition, callback) => {
-	const hasRunRef = useRef(false);
-	const stableCallback = useStableCallback(callback);
-	useEffect(() => {
-		if (Boolean(condition) && !hasRunRef.current) {
-			hasRunRef.current = true;
-			stableCallback();
-		}
-	}, [condition, stableCallback]);
-};
-
-//#endregion
-//#region src/react/useLocalOnce.ts
-/**
-* Runs a callback only once when a condition becomes truthy, executing synchronously
-* during render. The callback is stabilized internally to always reference the latest version.
-*
-* Unlike `useOnce`, this runs at the top level of the hook (not in useEffect),
-* making it suitable for state updates that need to happen synchronously during render.
-*
-* @param condition - When truthy (evaluated via Boolean()), the callback will be executed (only once).
-* @param callback - The function to run once when the condition is met.
-*
-* @example
-* ```tsx
-* const user: User | null = getUser();
-* useLocalOnce(user, () => {
-*   setState(user.name);
-* });
-* ```
-*/
-const useLocalOnce = (condition, callback) => {
-	const hasRunRef = useRef(false);
-	const stableCallback = useStableCallback(callback);
-	if (Boolean(condition) && !hasRunRef.current) {
-		hasRunRef.current = true;
-		stableCallback();
-	}
-};
-
-//#endregion
-//#region src/react/useOnMount.ts
-/**
-* Calls the given callback when the component mounts.
-* Uses useStableCallback internally to ensure the latest version is called.
-*
-* @param callback - The function to run when the component mounts.
-*
-* @example
-* ```tsx
-* useOnMount(() => {
-*   console.log("Component mounted!");
-* });
-* ```
-*/
-const useOnMount = (callback) => {
-	const stableCallback = useStableCallback(callback);
-	useEffect(() => {
-		stableCallback();
-	}, [stableCallback]);
-};
-
-//#endregion
-//#region src/react/useOnUnmount.ts
-/**
-* Calls the given callback when the component unmounts.
-* Uses useStableCallback internally to ensure the latest version is called.
-*/
-const useOnUnmount = (callback) => {
-	const stableCallback = useStableCallback(callback);
-	useEffect(() => {
-		return () => {
-			stableCallback();
-		};
-	}, [stableCallback]);
-};
-
-//#endregion
-export { useLocalOnce, useOnMount, useOnUnmount, useOnce, useStableCallback };
-//# sourceMappingURL=react.mjs.map

package/dist/react.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"react.mjs","names":[],"sources":["../src/react/useStableCallback.ts","../src/react/useOnce.ts","../src/react/useLocalOnce.ts","../src/react/useOnMount.ts","../src/react/useOnUnmount.ts"],"sourcesContent":["// oxlint-disable no-explicit-any\r\n\r\nimport { useCallback, useRef } from \"react\";\r\n\r\ntype AnyFunction = (...args: any[]) => any;\r\ntype AnyArgs = any[];\r\n\r\n/**\r\n * Creates a stable callback that always calls the latest version of the function.\r\n * Useful for callbacks that need to be used in dependency arrays but should always\r\n * execute the most recent version of the callback.\r\n */\r\nexport const useStableCallback = <T extends AnyFunction>(callback: T): T => {\r\n  const callbackRef = useRef(callback);\r\n\r\n  // Update the ref on every render\r\n  callbackRef.current = callback;\r\n\r\n  return useCallback((...args: AnyArgs) => {\r\n    return callbackRef.current(...args);\r\n  }, []) as T;\r\n};\r\n","import { useEffect, useRef } from \"react\";\r\nimport { useStableCallback } from \"./useStableCallback\";\r\n\r\n/**\r\n * Runs a callback only once when a condition becomes truthy.\r\n * The callback is stabilized internally to always reference the latest version.\r\n *\r\n * @param condition - When truthy (evaluated via Boolean()), the callback will be executed (only once).\r\n * @param callback - The function to run once when the condition is met.\r\n *\r\n * @example\r\n * ```tsx\r\n * const isReady = true;\r\n * useOnce(isReady, () => {\r\n *   console.log(\"Ready!\");\r\n * });\r\n * ```\r\n */\r\nexport const useOnce = (condition: unknown, callback: () => void): void => {\r\n  const hasRunRef = useRef(false);\r\n  const stableCallback = useStableCallback(callback);\r\n\r\n  useEffect(() => {\r\n    if (Boolean(condition) && !hasRunRef.current) {\r\n      hasRunRef.current = true;\r\n      stableCallback();\r\n    }\r\n  }, [condition, stableCallback]);\r\n};\r\n","import { useRef } from \"react\";\r\nimport { useStableCallback } from \"./useStableCallback\";\r\n\r\n/**\r\n * Runs a callback only once when a condition becomes truthy, executing synchronously\r\n * during render. The callback is stabilized internally to always reference the latest version.\r\n *\r\n * Unlike `useOnce`, this runs at the top level of the hook (not in useEffect),\r\n * making it suitable for state updates that need to happen synchronously during render.\r\n *\r\n * @param condition - When truthy (evaluated via Boolean()), the callback will be executed (only once).\r\n * @param callback - The function to run once when the condition is met.\r\n *\r\n * @example\r\n * ```tsx\r\n * const user: User | null = getUser();\r\n * useLocalOnce(user, () => {\r\n *   setState(user.name);\r\n * });\r\n * ```\r\n */\r\nexport const useLocalOnce = (condition: unknown, callback: () => void): void => {\r\n  const hasRunRef = useRef(false);\r\n  const stableCallback = useStableCallback(callback);\r\n\r\n  if (Boolean(condition) && !hasRunRef.current) {\r\n    hasRunRef.current = true;\r\n    stableCallback();\r\n  }\r\n};\r\n","import { useEffect } from \"react\";\nimport { useStableCallback } from \"./useStableCallback\";\n\n/**\n * Calls the given callback when the component mounts.\n * Uses useStableCallback internally to ensure the latest version is called.\n *\n * @param callback - The function to run when the component mounts.\n *\n * @example\n * ```tsx\n * useOnMount(() => {\n *   console.log(\"Component mounted!\");\n * });\n * ```\n */\nexport const useOnMount = (callback: () => void): void => {\n  const stableCallback = useStableCallback(callback);\n\n  useEffect(() => {\n    stableCallback();\n  }, [stableCallback]);\n};\n","import { useEffect } from \"react\";\r\nimport { useStableCallback } from \"./useStableCallback\";\r\n\r\n/**\r\n * Calls the given callback when the component unmounts.\r\n * Uses useStableCallback internally to ensure the latest version is called.\r\n */\r\nexport const useOnUnmount = (callback: () => void): void => {\r\n  const stableCallback = useStableCallback(callback);\r\n\r\n  useEffect(() => {\r\n    return () => {\r\n      stableCallback();\r\n    };\r\n  }, [stableCallback]);\r\n};\r\n"],"mappings":";;;;;;;;AAYA,MAAa,qBAA4C,aAAmB;CAC1E,MAAM,cAAc,OAAO,SAAS;AAGpC,aAAY,UAAU;AAEtB,QAAO,aAAa,GAAG,SAAkB;AACvC,SAAO,YAAY,QAAQ,GAAG,KAAK;IAClC,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;ACFR,MAAa,WAAW,WAAoB,aAA+B;CACzE,MAAM,YAAY,OAAO,MAAM;CAC/B,MAAM,iBAAiB,kBAAkB,SAAS;AAElD,iBAAgB;AACd,MAAI,QAAQ,UAAU,IAAI,CAAC,UAAU,SAAS;AAC5C,aAAU,UAAU;AACpB,mBAAgB;;IAEjB,CAAC,WAAW,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;ACNjC,MAAa,gBAAgB,WAAoB,aAA+B;CAC9E,MAAM,YAAY,OAAO,MAAM;CAC/B,MAAM,iBAAiB,kBAAkB,SAAS;AAElD,KAAI,QAAQ,UAAU,IAAI,CAAC,UAAU,SAAS;AAC5C,YAAU,UAAU;AACpB,kBAAgB;;;;;;;;;;;;;;;;;;;ACXpB,MAAa,cAAc,aAA+B;CACxD,MAAM,iBAAiB,kBAAkB,SAAS;AAElD,iBAAgB;AACd,kBAAgB;IACf,CAAC,eAAe,CAAC;;;;;;;;;ACdtB,MAAa,gBAAgB,aAA+B;CAC1D,MAAM,iBAAiB,kBAAkB,SAAS;AAElD,iBAAgB;AACd,eAAa;AACX,mBAAgB;;IAEjB,CAAC,eAAe,CAAC"}