rura 1.0.8 → 1.1.0

package/README.md

@@ -2,16 +2,13 @@
 
 <div align="center">
 
-A minimal **pipeline engine** for every modern workflow,  
-built for clarity and stability.
+The hook pipeline
 
 </div>
 
 <div align="center">
 
 [![NPM version](https://img.shields.io/npm/v/rura?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/rura)
-[![Bundle size](https://img.shields.io/bundlephobia/minzip/rura?style=flat&colorA=000000&colorB=000000)](https://bundlephobia.com/package/rura)
-[![Coverage Status](https://img.shields.io/coveralls/github/yiming-liao/rura.svg?branch=main&style=flat&colorA=000000&colorB=000000)](https://coveralls.io/github/yiming-liao/rura?branch=main)
 [![TypeScript](https://img.shields.io/badge/TypeScript-%E2%9C%94-blue?style=flat&colorA=000000&colorB=000000)](https://www.typescriptlang.org/)
 [![License](https://img.shields.io/npm/l/rura?style=flat&colorA=000000&colorB=000000)](LICENSE)
 
@@ -19,158 +16,81 @@ built for clarity and stability.
 
 ## Features
 
-- **Deterministic** – Ordered hooks with effortless early exit.
-- **Typed** – Inferred context and output with zero boilerplate.
-- **Universal** – Tiny, framework-agnostic, and ready for any flow.
+- **Deterministic** — Strict hook ordering with early termination.
+- **Type-safe** — Fully inferred context and output.
+- **Composable** — Minimal and framework-agnostic.
 
 ## Installation
 
 ```bash
-# npm
 npm install rura
-# yarn
+# or
 yarn add rura
-# pnpm
+# or
 pnpm add rura
 ```
 
-## Quick Start
-
-#### 1. Define the initial context
+## Example
 
 ```ts
-const ctx = { count: 1 };
-type Ctx = typeof ctx;
-```
-
-#### 2. Create your hooks
-
-- Hooks can be created with `rura.createHook`, or defined manually using the `RuraHook` type.
-- Hooks may specify an `order`; omitted values default to `0`.
+import { rura } from "rura";
 
-```ts
-import { rura, type RuraHook } from "rura";
+// Shared pipeline context.
+type Ctx = { count: number };
 
-// With createHook (recommended for convenience)
+// Synchronous hook.
 const addOne = rura.createHook<Ctx>("add-one", (ctx) => {
   ctx.count += 1;
-}); // order: 0
+});
 
-// Manual hook definition (full control)
-const stopIfEven: RuraHook<Ctx, number> = {
-  name: "stop-if-even",
-  run: (ctx) => {
+// Synchronous hook (Early-terminating).
+const stopIfEven = rura.createHook<Ctx, number>(
+  "stop-if-even",
+  (ctx) => {
     if (ctx.count % 2 === 0) {
       return { early: true, output: ctx.count };
     }
   },
-  order: 2, // order: 2
-};
-```
-
-- Rura executes hooks in order and exits early when a hook returns `{ early: true, output }`.
+  2, // optional execution order
+);
 
-- When the pipeline does not exit early, `output` is omitted and `early` becomes `false`.
+// Deterministic execution.
+const result = rura.run({ count: 1 }, [addOne, stopIfEven, addOne]);
+```
 
-#### 3. Run the pipeline
+Asynchronous variant:
 
 ```ts
-const result = rura.run(ctx, [addOne, stopIfEven]);
-
-console.log(result);
-// -> {
-//      early: true,
-//      ctx: { count: 2 },
-//      output: 2
-//    }
+rura.createHookAsync(...)
+rura.runAsync(...)
 ```
 
-> Note: If your hooks are asynchronous,  
-> use `rura.createHookAsync()` and run them through `rura.runAsync()` accordingly.
-
 ---
 
 ## Pipeline Builder
 
-> If you prefer working with a reusable pipeline instance
-
-**rura.createPipeline()** - Creates a lightweight, composable pipeline instance  
-that can register hooks, merge with other pipelines, and be inspected.
+Reusable pipeline instance:
 
 ```ts
-import { rura } from "rura";
+const pipeline = rura.createPipeline<Ctx>();
 
-const pipeline = rura.createPipeline<Context, Output>();
+pipeline.use(hookA).use(hookB);
 
-// Add hooks
-pipeline
-  .use(hookA) // chainable
-  .use(hookB)
-  .use(hookC);
+const result = pipeline.run({ count: 1 });
 ```
 
-example:
+Asynchronous variant:
 
 ```ts
-type Ctx = { value: number };
-
-// Create a reusable pipeline instance
-const pipelineA = rura.createPipeline<Ctx>();
-
-// Register a hook using `use()`
-pipelineA.use({
-  name: "add-two",
-  run: (ctx) => {
-    ctx.value += 2;
-  },
-});
-
-// Create another pipeline (preloaded with hooks)
-const pipelineB = rura.createPipeline<Ctx>([
-  {
-    name: "multiply-three",
-    run: (ctx) => {
-      ctx.value *= 3;
-    },
-  },
-]);
-
-// Merge pipelines into a single combined pipeline
-const pipeline = pipelineA.merge(pipelineB);
-
-// Execute the pipeline
-const result = await pipeline.run({ value: 1 });
-
-console.log(result);
-// -> {
-//      early: false,
-//      ctx: { value: 9 }
-//    }
+const pipeline = rura.createPipelineAsync<Ctx>();
+await pipeline.run(ctx);
 ```
 
-> Note: If your pipeline includes async hooks,  
-> be sure to use `rura.createPipelineAsync()`, which awaits each hook in order.
-
-#### Pipeline Instance Methods
-
-`rura.createPipeline()` — Synchronous Pipeline
-
-| Method           | Description                                                       | Parameters | Returns            |
-| ---------------- | ----------------------------------------------------------------- | ---------- | ------------------ |
-| **use(hook)**    | Adds a hook, normalizes its order, and re-sorts hooks.            | `hook`     | `this` (chainable) |
-| **merge(other)** | Merges hooks from another pipeline and re-sorts them.             | `other`    | `this` (chainable) |
-| **getHooks()**   | Returns a sorted shallow copy of all registered hooks.            | –          | `RuraHook[]`       |
-| **debugHooks()** | Prints a formatted, human-readable hook list.                     | –          | `void`             |
-| **run(ctx)**     | Executes the pipeline synchronously. (delegates to `rura.run()`). | `ctx`      | `RuraResult`       |
-
-<br/>
-
-`rura.createPipelineAsync()` — Asynchronous Pipeline
+#### Pipeline Instance API
 
-| Method           | Description                                                             | Parameters | Returns               |
-| ---------------- | ----------------------------------------------------------------------- | ---------- | --------------------- |
-| **use(hook)**    | Adds a hook, normalizes its order, and re-sorts hooks.                  | `hook`     | `this` (chainable)    |
-| **merge(other)** | Merges hooks from another pipeline and re-sorts them.                   | `other`    | `this` (chainable)    |
-| **getHooks()**   | Returns a sorted shallow copy of all registered hooks.                  | –          | `RuraHook[]`          |
-| **debugHooks()** | Prints a formatted, human-readable hook list.                           | –          | `void`                |
-| **run(ctx)**     | Executes the pipeline asynchronously. (delegates to `rura.runAsync()`). | `ctx`      | `Promise<RuraResult>` |
+| Method       | Description                                 | Returns                  |
+| ------------ | ------------------------------------------- | ------------------------ |
+| **use**      | Registers a hook and re-sorts the pipeline. | `this` (chainable)       |
+| **getHooks** | Returns a shallow copy of sorted hooks.     | `Hook[]`                 |
+| **logHooks** | Logs hook order and execution type.         | `void`                   |
+| **run**      | Executes the pipeline.                      | `RuraResult` / `Promise` |

package/dist/index.cjs

@@ -1,87 +1,95 @@
 'use strict';
 
+// src/hooks/internal.ts
+var ASYNC_HOOK = /* @__PURE__ */ Symbol("rura.async");
+
 // src/hooks/create-hook.ts
 function createHook(name, run2, order) {
-  return { name, run: run2, order };
+  const hook = {
+    name,
+    run: run2,
+    ...order !== void 0 ? { order } : {}
+  };
+  return hook;
 }
 function createHookAsync(name, run2, order) {
-  return { name, run: run2, order };
+  const hook = {
+    name,
+    run: run2,
+    ...order !== void 0 ? { order } : {},
+    [ASYNC_HOOK]: true
+  };
+  return hook;
 }
 
 // src/hooks/utils/is-async-hook.ts
 function isAsyncHook(hook) {
-  return hook.run.constructor.name === "AsyncFunction";
+  return hook[ASYNC_HOOK] === true;
 }
 
-// src/pipeline/create/utils/format-debug-message.ts
-var formatDebugMessage = (hooks, name, title) => {
-  if (title) {
-    console.log(`
-${title(hooks)}`);
-  } else {
-    const label = name ? ` <${name}>` : "";
-    console.log(`
-\u{1F30A} Rura Pipeline${label} (${hooks.length} hooks)`);
+// src/pipeline/create/utils/assert-sync-hook.ts
+function assertSyncHook(hook) {
+  if (isAsyncHook(hook)) {
+    throw new Error(
+      `Async hook "${hook.name}" is not allowed in sync pipeline.`
+    );
   }
-  console.log(`\u2500\u2500\u2500`);
+}
+
+// src/pipeline/create/utils/log-pipeline-hooks.ts
+function logPipelineHooks(hooks, name = "Rura") {
+  const count = hooks.length;
+  const suffix = count === 1 ? "hook" : "hooks";
+  console.log(`${name} (${count} ${suffix})`);
+  console.log("\u2500\u2500\u2500");
   hooks.forEach((hook, i) => {
     const kind = isAsyncHook(hook) ? "async" : "sync";
+    const order = hook.order ?? "-";
     console.log(
-      `${i + 1}. order:${String(hook.order).padStart(4)} | ${hook.name} (${kind})`
+      `${i + 1}. order: ${String(order).padEnd(4)} | ${hook.name} (${kind})`
     );
   });
-  console.log(`\u2500\u2500\u2500
-`);
-};
+  console.log("\u2500\u2500\u2500");
+}
 
 // src/pipeline/create/create-pipeline-base.ts
 function createPipelineBase(initialHooks, runFn, options) {
+  const isSync = options.mode === "sync";
+  if (isSync) for (const hook of initialHooks) assertSyncHook(hook);
   const name = options.name;
-  const hooks = initialHooks.map((h) => applyDefaultOrder(h));
-  function applyDefaultOrder(h) {
-    return { ...h, order: h.order ?? 0 };
-  }
+  const hooks = [...initialHooks];
   function sortHooks() {
-    hooks.sort((a, b) => a.order - b.order);
+    hooks.sort((a, b) => {
+      const ao = a.order ?? Number.POSITIVE_INFINITY;
+      const bo = b.order ?? Number.POSITIVE_INFINITY;
+      return ao - bo;
+    });
   }
-  function use(h) {
-    if (options.mode === "sync" && isAsyncHook(h)) {
-      throw new Error(`Async hook "${h.name}" is not allowed in createRura().`);
-    }
-    hooks.push(applyDefaultOrder(h));
-    sortHooks();
-    return api;
-  }
-  function merge(other) {
-    other.getHooks().forEach((h) => hooks.push(applyDefaultOrder(h)));
+  function use(hook) {
+    if (isSync) assertSyncHook(hook);
+    hooks.push(hook);
     sortHooks();
-    return api;
+    return pipeline;
   }
   function getHooks() {
     return [...hooks];
   }
-  function debugHooks(title) {
-    formatDebugMessage(hooks, name, title);
+  function logHooks() {
+    logPipelineHooks(hooks, name);
   }
   function run2(ctx) {
-    return runFn(ctx, hooks);
+    return runFn(ctx, [...hooks]);
   }
-  const api = { use, merge, getHooks, debugHooks, run: run2 };
+  const pipeline = { use, getHooks, logHooks, run: run2 };
   sortHooks();
-  return api;
+  return pipeline;
 }
 
 // src/pipeline/run/run.ts
 function run(ctx, hooks) {
   for (const hook of hooks) {
-    if (isAsyncHook(hook)) {
-      throw new Error(
-        `Async hook "${hook.name}" detected in run(). Use runAsync() instead.`
-      );
-    }
     const result = hook.run(ctx);
-    const isEarlyReturn = result && result.early === true;
-    if (isEarlyReturn) {
+    if (result?.early === true) {
       return {
         early: true,
         ctx,
@@ -95,20 +103,11 @@ function run(ctx, hooks) {
   };
 }
 
-// src/pipeline/create/create-pipeline.ts
-function createPipeline(hooks = []) {
-  return createPipelineBase(
-    hooks,
-    run,
-    { mode: "sync" }
-  );
-}
-
 // src/pipeline/run/run-async.ts
 async function runAsync(ctx, hooks) {
   for (const hook of hooks) {
     const result = await hook.run(ctx);
-    if (result && result.early === true) {
+    if (result?.early === true) {
       return {
         early: true,
         ctx,
@@ -122,6 +121,15 @@ async function runAsync(ctx, hooks) {
   };
 }
 
+// src/pipeline/create/create-pipeline.ts
+function createPipeline(hooks = []) {
+  return createPipelineBase(
+    hooks,
+    run,
+    { mode: "sync" }
+  );
+}
+
 // src/pipeline/create/create-pipeline-async.ts
 function createPipelineAsync(hooks = []) {
   return createPipelineBase(
@@ -132,18 +140,22 @@ function createPipelineAsync(hooks = []) {
 }
 
 // src/rura.ts
-var rura = {
-  // hook factories
+var rura = Object.freeze({
+  // Hook creation
   createHook,
   createHookAsync,
-  // executors
+  // Direct execution
   run,
   runAsync,
-  // pipeline constructors
+  // Pipeline construction
   createPipeline,
-  createPipelineAsync,
-  // utils
-  isAsyncHook
-};
+  createPipelineAsync
+});
 
+exports.createHook = createHook;
+exports.createHookAsync = createHookAsync;
+exports.createPipeline = createPipeline;
+exports.createPipelineAsync = createPipelineAsync;
+exports.run = run;
+exports.runAsync = runAsync;
 exports.rura = rura;

package/dist/index.js

@@ -1,85 +1,93 @@
+// src/hooks/internal.ts
+var ASYNC_HOOK = /* @__PURE__ */ Symbol("rura.async");
+
 // src/hooks/create-hook.ts
 function createHook(name, run2, order) {
-  return { name, run: run2, order };
+  const hook = {
+    name,
+    run: run2,
+    ...order !== void 0 ? { order } : {}
+  };
+  return hook;
 }
 function createHookAsync(name, run2, order) {
-  return { name, run: run2, order };
+  const hook = {
+    name,
+    run: run2,
+    ...order !== void 0 ? { order } : {},
+    [ASYNC_HOOK]: true
+  };
+  return hook;
 }
 
 // src/hooks/utils/is-async-hook.ts
 function isAsyncHook(hook) {
-  return hook.run.constructor.name === "AsyncFunction";
+  return hook[ASYNC_HOOK] === true;
 }
 
-// src/pipeline/create/utils/format-debug-message.ts
-var formatDebugMessage = (hooks, name, title) => {
-  if (title) {
-    console.log(`
-${title(hooks)}`);
-  } else {
-    const label = name ? ` <${name}>` : "";
-    console.log(`
-\u{1F30A} Rura Pipeline${label} (${hooks.length} hooks)`);
+// src/pipeline/create/utils/assert-sync-hook.ts
+function assertSyncHook(hook) {
+  if (isAsyncHook(hook)) {
+    throw new Error(
+      `Async hook "${hook.name}" is not allowed in sync pipeline.`
+    );
   }
-  console.log(`\u2500\u2500\u2500`);
+}
+
+// src/pipeline/create/utils/log-pipeline-hooks.ts
+function logPipelineHooks(hooks, name = "Rura") {
+  const count = hooks.length;
+  const suffix = count === 1 ? "hook" : "hooks";
+  console.log(`${name} (${count} ${suffix})`);
+  console.log("\u2500\u2500\u2500");
   hooks.forEach((hook, i) => {
     const kind = isAsyncHook(hook) ? "async" : "sync";
+    const order = hook.order ?? "-";
     console.log(
-      `${i + 1}. order:${String(hook.order).padStart(4)} | ${hook.name} (${kind})`
+      `${i + 1}. order: ${String(order).padEnd(4)} | ${hook.name} (${kind})`
     );
   });
-  console.log(`\u2500\u2500\u2500
-`);
-};
+  console.log("\u2500\u2500\u2500");
+}
 
 // src/pipeline/create/create-pipeline-base.ts
 function createPipelineBase(initialHooks, runFn, options) {
+  const isSync = options.mode === "sync";
+  if (isSync) for (const hook of initialHooks) assertSyncHook(hook);
   const name = options.name;
-  const hooks = initialHooks.map((h) => applyDefaultOrder(h));
-  function applyDefaultOrder(h) {
-    return { ...h, order: h.order ?? 0 };
-  }
+  const hooks = [...initialHooks];
   function sortHooks() {
-    hooks.sort((a, b) => a.order - b.order);
+    hooks.sort((a, b) => {
+      const ao = a.order ?? Number.POSITIVE_INFINITY;
+      const bo = b.order ?? Number.POSITIVE_INFINITY;
+      return ao - bo;
+    });
   }
-  function use(h) {
-    if (options.mode === "sync" && isAsyncHook(h)) {
-      throw new Error(`Async hook "${h.name}" is not allowed in createRura().`);
-    }
-    hooks.push(applyDefaultOrder(h));
-    sortHooks();
-    return api;
-  }
-  function merge(other) {
-    other.getHooks().forEach((h) => hooks.push(applyDefaultOrder(h)));
+  function use(hook) {
+    if (isSync) assertSyncHook(hook);
+    hooks.push(hook);
     sortHooks();
-    return api;
+    return pipeline;
   }
   function getHooks() {
     return [...hooks];
   }
-  function debugHooks(title) {
-    formatDebugMessage(hooks, name, title);
+  function logHooks() {
+    logPipelineHooks(hooks, name);
   }
   function run2(ctx) {
-    return runFn(ctx, hooks);
+    return runFn(ctx, [...hooks]);
   }
-  const api = { use, merge, getHooks, debugHooks, run: run2 };
+  const pipeline = { use, getHooks, logHooks, run: run2 };
   sortHooks();
-  return api;
+  return pipeline;
 }
 
 // src/pipeline/run/run.ts
 function run(ctx, hooks) {
   for (const hook of hooks) {
-    if (isAsyncHook(hook)) {
-      throw new Error(
-        `Async hook "${hook.name}" detected in run(). Use runAsync() instead.`
-      );
-    }
     const result = hook.run(ctx);
-    const isEarlyReturn = result && result.early === true;
-    if (isEarlyReturn) {
+    if (result?.early === true) {
       return {
         early: true,
         ctx,
@@ -93,20 +101,11 @@ function run(ctx, hooks) {
   };
 }
 
-// src/pipeline/create/create-pipeline.ts
-function createPipeline(hooks = []) {
-  return createPipelineBase(
-    hooks,
-    run,
-    { mode: "sync" }
-  );
-}
-
 // src/pipeline/run/run-async.ts
 async function runAsync(ctx, hooks) {
   for (const hook of hooks) {
     const result = await hook.run(ctx);
-    if (result && result.early === true) {
+    if (result?.early === true) {
       return {
         early: true,
         ctx,
@@ -120,6 +119,15 @@ async function runAsync(ctx, hooks) {
   };
 }
 
+// src/pipeline/create/create-pipeline.ts
+function createPipeline(hooks = []) {
+  return createPipelineBase(
+    hooks,
+    run,
+    { mode: "sync" }
+  );
+}
+
 // src/pipeline/create/create-pipeline-async.ts
 function createPipelineAsync(hooks = []) {
   return createPipelineBase(
@@ -130,18 +138,16 @@ function createPipelineAsync(hooks = []) {
 }
 
 // src/rura.ts
-var rura = {
-  // hook factories
+var rura = Object.freeze({
+  // Hook creation
   createHook,
   createHookAsync,
-  // executors
+  // Direct execution
   run,
   runAsync,
-  // pipeline constructors
+  // Pipeline construction
   createPipeline,
-  createPipelineAsync,
-  // utils
-  isAsyncHook
-};
+  createPipelineAsync
+});
 
-export { rura };
+export { createHook, createHookAsync, createPipeline, createPipelineAsync, run, runAsync, rura };

package/dist/types/export/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Rura — The hook pipeline.
+ *
+ * @packageDocumentation
+ */
+export { rura } from "../src/rura";
+export { createHook, createHookAsync, type RuraHookBase, type RuraHookSync, type RuraHookAsync, type RuraHook, } from "../src/hooks";
+export { createPipeline, createPipelineAsync, run, runAsync, type RuraResult, } from "../src/pipeline";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../export/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAGnC,OAAO,EACL,UAAU,EACV,eAAe,EACf,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,QAAQ,GACd,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,GAAG,EACH,QAAQ,EACR,KAAK,UAAU,GAChB,MAAM,iBAAiB,CAAC"}

package/dist/types/src/hooks/create-hook.d.ts

@@ -0,0 +1,18 @@
+import type { RuraHookAsync, RuraHookSync } from "./types";
+/**
+ * Creates a synchronous hook.
+ *
+ * The hook executes without awaiting.
+ *
+ * @public
+ */
+export declare function createHook<Ctx = unknown, Out = unknown>(name: string, run: RuraHookSync<Ctx, Out>["run"], order?: number): RuraHookSync<Ctx, Out>;
+/**
+ * Creates an asynchronous hook.
+ *
+ * The hook executes via `await`.
+ *
+ * @public
+ */
+export declare function createHookAsync<Ctx = unknown, Out = unknown>(name: string, run: RuraHookAsync<Ctx, Out>["run"], order?: number): RuraHookAsync<Ctx, Out>;
+//# sourceMappingURL=create-hook.d.ts.map

package/dist/types/src/hooks/create-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-hook.d.ts","sourceRoot":"","sources":["../../../../src/hooks/create-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG3D;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,GAAG,GAAG,OAAO,EAAE,GAAG,GAAG,OAAO,EACrD,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,EAClC,KAAK,CAAC,EAAE,MAAM,GACb,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAQxB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,GAAG,OAAO,EAAE,GAAG,GAAG,OAAO,EAC1D,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,EACnC,KAAK,CAAC,EAAE,MAAM,GACb,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CASzB"}

package/dist/types/src/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { createHook, createHookAsync } from "./create-hook";
+export type { RuraHookBase, RuraHookSync, RuraHookAsync, RuraHook, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAC5D,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,QAAQ,GACT,MAAM,SAAS,CAAC"}

package/dist/types/src/hooks/internal.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=internal.d.ts.map

package/dist/types/src/hooks/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../../../src/hooks/internal.ts"],"names":[],"mappings":""}