@comapeo/map-server 1.0.0-pre.0

package/dist/types.d.ts

@@ -0,0 +1,110 @@
+import type { RequestLike } from 'itty-router';
+import { Type as T, type Static } from 'typebox';
+export declare const MapShareDeclineReason: T.TUnion<[T.TLiteral<"disk_full">, T.TLiteral<"user_rejected">, T.TString]>;
+declare const MapShareStateUpdate: T.TUnion<[T.TObject<{
+    status: T.TLiteral<"pending">;
+}>, T.TObject<{
+    status: T.TLiteral<"declined">;
+    reason: T.TUnion<[T.TLiteral<"disk_full">, T.TLiteral<"user_rejected">, T.TString]>;
+}>, T.TObject<{
+    status: T.TLiteral<"downloading">;
+    bytesDownloaded: T.TNumber;
+}>, T.TObject<{
+    status: T.TLiteral<"canceled">;
+}>, T.TObject<{
+    status: T.TLiteral<"aborted">;
+}>, T.TObject<{
+    status: T.TLiteral<"completed">;
+}>, T.TObject<{
+    status: T.TLiteral<"error">;
+    error: T.TObject<{
+        message: T.TString;
+        code: T.TString;
+    }>;
+}>]>;
+export type MapShareStateUpdate = Static<typeof MapShareStateUpdate>;
+export type MapShareStatus = Static<typeof MapShareStateUpdate>['status'];
+export type DownloadStateUpdate = Extract<MapShareStateUpdate, {
+    status: 'downloading' | 'completed' | 'error' | 'canceled' | 'aborted';
+}>;
+export declare const MapShareUrls: T.TArray<T.TString>;
+export declare const ShareId: T.TString;
+export type ShareId = Static<typeof ShareId>;
+export declare const EstimatedSizeBytes: T.TNumber;
+declare const MapInfo: T.TObject<{
+    mapId: T.TString;
+    mapName: T.TString;
+    estimatedSizeBytes: T.TNumber;
+    bounds: T.TImmutable<T.TTuple<[T.TNumber, T.TNumber, T.TNumber, T.TNumber]>>;
+    minzoom: T.TNumber;
+    maxzoom: T.TNumber;
+    mapCreated: T.TNumber;
+}>;
+declare const MapShareBase: T.TIntersect<[T.TObject<{
+    receiverDeviceId: T.TString;
+    shareId: T.TString;
+    mapShareUrls: T.TArray<T.TString>;
+    mapShareCreated: T.TNumber;
+}>, T.TObject<{
+    mapId: T.TString;
+    mapName: T.TString;
+    estimatedSizeBytes: T.TNumber;
+    bounds: T.TImmutable<T.TTuple<[T.TNumber, T.TNumber, T.TNumber, T.TNumber]>>;
+    minzoom: T.TNumber;
+    maxzoom: T.TNumber;
+    mapCreated: T.TNumber;
+}>]>;
+export declare const MapShareState: T.TIntersect<[T.TIntersect<[T.TObject<{
+    receiverDeviceId: T.TString;
+    shareId: T.TString;
+    mapShareUrls: T.TArray<T.TString>;
+    mapShareCreated: T.TNumber;
+}>, T.TObject<{
+    mapId: T.TString;
+    mapName: T.TString;
+    estimatedSizeBytes: T.TNumber;
+    bounds: T.TImmutable<T.TTuple<[T.TNumber, T.TNumber, T.TNumber, T.TNumber]>>;
+    minzoom: T.TNumber;
+    maxzoom: T.TNumber;
+    mapCreated: T.TNumber;
+}>]>, T.TUnion<[T.TObject<{
+    status: T.TLiteral<"pending">;
+}>, T.TObject<{
+    status: T.TLiteral<"declined">;
+    reason: T.TUnion<[T.TLiteral<"disk_full">, T.TLiteral<"user_rejected">, T.TString]>;
+}>, T.TObject<{
+    status: T.TLiteral<"downloading">;
+    bytesDownloaded: T.TNumber;
+}>, T.TObject<{
+    status: T.TLiteral<"canceled">;
+}>, T.TObject<{
+    status: T.TLiteral<"aborted">;
+}>, T.TObject<{
+    status: T.TLiteral<"completed">;
+}>, T.TObject<{
+    status: T.TLiteral<"error">;
+    error: T.TObject<{
+        message: T.TString;
+        code: T.TString;
+    }>;
+}>]>]>;
+export type MapShareState = DistributiveIntersection<Static<typeof MapShareBase>, Static<typeof MapShareStateUpdate>>;
+export type MapInfo = Static<typeof MapInfo>;
+export type FetchContext = {
+    isLocalhost?: boolean;
+    remoteDeviceId?: string;
+};
+export type DistributiveIntersection<Base, Union> = Union extends unknown ? Base & Union : never;
+export type DistributeProperty<T, K extends keyof T> = T[K] extends infer V ? V extends T[K] ? {
+    [P in K]: V;
+} & Omit<T, K> : never : never;
+/**
+ * External router returned by create router functions. Ensures routers are
+ * called with the necessary fetch context
+ */
+export type RouterExternal = {
+    fetch: (request: RequestLike, context: FetchContext) => Promise<any>;
+};
+export type BBox = Readonly<[number, number, number, number]>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EAAE,IAAI,IAAI,CAAC,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAA;AAEhD,eAAO,MAAM,qBAAqB,6EAYhC,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;IAgDvB,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACpE,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC,QAAQ,CAAC,CAAA;AAEzE,MAAM,MAAM,mBAAmB,GAAG,OAAO,CACxC,mBAAmB,EACnB;IAAE,MAAM,EAAE,aAAa,GAAG,WAAW,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,CAAA;CAAE,CAC1E,CAAA;AAED,eAAO,MAAM,YAAY,qBAIvB,CAAA;AACF,eAAO,MAAM,OAAO,WAGlB,CAAA;AACF,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,OAAO,CAAC,CAAA;AAC5C,eAAO,MAAM,kBAAkB,WAE7B,CAAA;AAEF,QAAA,MAAM,OAAO;;;;;;;;EAcX,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;IAYhB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAmD,CAAA;AAE7E,MAAM,MAAM,aAAa,GAAG,wBAAwB,CACnD,MAAM,CAAC,OAAO,YAAY,CAAC,EAC3B,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAClC,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,OAAO,CAAC,CAAA;AAE5C,MAAM,MAAM,YAAY,GAAG;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,cAAc,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,wBAAwB,CAAC,IAAI,EAAE,KAAK,IAAI,KAAK,SAAS,OAAO,GACtE,IAAI,GAAG,KAAK,GACZ,KAAK,CAAA;AAER,MAAM,MAAM,kBAAkB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,CAAC,GACxE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GACb;KAAG,CAAC,IAAI,CAAC,GAAG,CAAC;CAAE,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5B,KAAK,GACN,KAAK,CAAA;AAER;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC5B,KAAK,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;CACpE,CAAA;AAED,MAAM,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA"}

package/dist/types.js

@@ -0,0 +1,96 @@
+import { Type as T } from 'typebox';
+export const MapShareDeclineReason = T.Union([
+    T.Literal('disk_full', {
+        description: "The map share was declined because the receiver's disk is full",
+    }),
+    T.Literal('user_rejected', {
+        description: 'The map share was declined by the user',
+    }),
+    T.String({
+        minLength: 1,
+        description: 'Other reason for declining the map share',
+    }),
+]);
+const MapShareStateUpdate = T.Union([
+    T.Object({
+        status: T.Literal('pending', {
+            description: 'Map share is awaiting a response',
+        }),
+    }),
+    T.Object({
+        status: T.Literal('declined', {
+            description: 'Map share has been declined',
+        }),
+        reason: MapShareDeclineReason,
+    }),
+    T.Object({
+        status: T.Literal('downloading', {
+            description: 'Map share is currently being downloaded',
+        }),
+        bytesDownloaded: T.Number({
+            description: 'Total bytes downloaded so far (compare with estimatedSizeBytes for progress)',
+        }),
+    }),
+    T.Object({
+        status: T.Literal('canceled', {
+            description: 'Map share has been canceled (by the sharer)',
+        }),
+    }),
+    T.Object({
+        status: T.Literal('aborted', {
+            description: 'Map share download was aborted (by the receiver)',
+        }),
+    }),
+    T.Object({
+        status: T.Literal('completed', { description: 'Map has been downloaded' }),
+    }),
+    T.Object({
+        status: T.Literal('error', {
+            description: 'An error occurred while downloading',
+        }),
+        error: T.Object({
+            message: T.String({ description: 'Error message' }),
+            code: T.String({ description: 'Error code' }),
+        }, {
+            description: 'Error that occurred while receiving the map share',
+        }),
+    }),
+]);
+export const MapShareUrls = T.Array(T.String({ format: 'uri' }), {
+    minItems: 1,
+    description: 'List of map share URLs (for each network interface of the sharer)',
+});
+export const ShareId = T.String({
+    minLength: 1,
+    description: 'The ID of the map share',
+});
+export const EstimatedSizeBytes = T.Number({
+    description: 'Estimated size of the map data in bytes',
+});
+const MapInfo = T.Object({
+    mapId: T.String({ description: 'The ID of the map' }),
+    mapName: T.String({ description: 'The name of the map' }),
+    estimatedSizeBytes: EstimatedSizeBytes,
+    bounds: T.ReadonlyType(T.Tuple([T.Number(), T.Number(), T.Number(), T.Number()], {
+        description: 'The bounding box of the map data',
+    })),
+    minzoom: T.Number({ description: 'The minimum zoom level of the map data' }),
+    maxzoom: T.Number({ description: 'The maximum zoom level of the map data' }),
+    mapCreated: T.Number({
+        description: 'Timestamp (ms since epoch) when the map was created',
+    }),
+});
+const MapShareBase = T.Intersect([
+    T.Object({
+        receiverDeviceId: T.String({
+            description: 'The ID of the device that can receive the map share',
+        }),
+        shareId: ShareId,
+        mapShareUrls: MapShareUrls,
+        mapShareCreated: T.Number({
+            description: 'Timestamp (ms since epoch) when the map share was created',
+        }),
+    }),
+    MapInfo,
+]);
+export const MapShareState = T.Intersect([MapShareBase, MapShareStateUpdate]);

package/node_modules/@envelop/instrumentation/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Dotan Simha
+
+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/node_modules/@envelop/instrumentation/README.md

@@ -0,0 +1,30 @@
+## `@envelop/instrumentation`
+
+This package contains utility functions and types to ease the use of instrumentation accross
+Envelop, Yoga, whatwg-node and Hive Gateway plugins.
+
+> [!NOTE] Instrumentation are automatically composed together. This should only be used if the
+> default ordering doesn't suit your needs (ie. instrumentation and hooks should be executed in
+> different order)
+
+## `composeInstrumentation(instrumentation: Instrumentation[]): Instrumentation`
+
+This function composes all the instrumentation into one. The instrumentation will be called in the
+same order as they are in the array (from top to bottom).
+
+```ts
+import { composeInstrumentation } from '@envelop/instrumentation'
+
+// Extract instrumentation to compose from their plugins
+const { instrumentation: instrumentation1, ...plugin1 } = usePlugin1()
+const { instrumentation: instrumentation2, ...plugin2 } = usePlugin2()
+
+const getEnveloped = envelop({
+  plugins: [
+    plugin1,
+    plugin2,
+    // Plugin instrumentation and plugin hooks will be executed in a different order
+    { instrumentation: composeInstrumentation([instrumentation1, instrumentation2]) }
+  ]
+})
+```

package/node_modules/@envelop/instrumentation/cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// eslint-disable-next-line import/export
+tslib_1.__exportStar(require("./instrumentation.js"), exports);

package/node_modules/@envelop/instrumentation/cjs/instrumentation.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstrumented = void 0;
+exports.chain = chain;
+exports.composeInstrumentation = composeInstrumentation;
+exports.getInstrumentationAndPlugin = getInstrumentationAndPlugin;
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
+/**
+ * Composes 2 instrumentations together into one instrumentation.
+ * The first one will be the outer call, the second one the inner call.
+ */
+function chain(first, next) {
+    const merged = { ...next, ...first };
+    for (const key of Object.keys(merged)) {
+        if (key in first && key in next) {
+            merged[key] = (payload, wrapped) => first[key](payload, () => next[key](payload, wrapped));
+        }
+    }
+    return merged;
+}
+/**
+ * Composes a list of instrumentation together into one instrumentation object.
+ * The order of execution will respect the order of the array,
+ * the first one being the outter most call, the last one the inner most call.
+ */
+function composeInstrumentation(instrumentation) {
+    return instrumentation.length > 0 ? instrumentation.reduce(chain) : undefined;
+}
+/**
+ * Extract instrumentation from a list of plugins.
+ * It returns instrumentation found, and the list of plugins without their instrumentation.
+ *
+ * You can use this to easily customize the composition of the instrumentation if the default one
+ * doesn't suits your needs.
+ */
+function getInstrumentationAndPlugin(plugins) {
+    const pluginInstrumentation = [];
+    const newPlugins = [];
+    for (const { instrumentation, ...plugin } of plugins) {
+        if (instrumentation) {
+            pluginInstrumentation.push(instrumentation);
+        }
+        newPlugins.push(plugin);
+    }
+    return { pluginInstrumentation, plugins: newPlugins };
+}
+/**
+ * A helper to instrument a function.
+ *
+ * @param payload: The first argument that will be passed to the instrumentation on each function call
+ * @returns Function and Async Functions factories allowing to wrap a function with a given instrument.
+ */
+const getInstrumented = (payload) => ({
+    /**
+     * Wraps the `wrapped` function with the given `instrument` wrapper.
+     * @returns The wrapped function, or `undefined` if the instrument is `undefined`.
+     */
+    fn(instrument, wrapped) {
+        if (!instrument) {
+            return wrapped;
+        }
+        return (...args) => {
+            let result;
+            instrument(payload, () => {
+                result = wrapped(...args);
+            });
+            return result;
+        };
+    },
+    /**
+     * Wraps the `wrapped` function with the given `instrument` wrapper.
+     * @returns The wrapped function, or `undefined` if the instrument is `undefined`.
+     */
+    asyncFn(instrument, wrapped) {
+        if (!instrument) {
+            return wrapped;
+        }
+        return (...args) => {
+            let result;
+            return (0, promise_helpers_1.handleMaybePromise)(() => instrument(payload, () => {
+                result = wrapped(...args);
+                return (0, promise_helpers_1.isPromise)(result) ? result.then(() => undefined) : undefined;
+            }), () => {
+                return result;
+            });
+        };
+    },
+});
+exports.getInstrumented = getInstrumented;

package/node_modules/@envelop/instrumentation/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/node_modules/@envelop/instrumentation/esm/index.js

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/export
+export * from './instrumentation.js';

package/node_modules/@envelop/instrumentation/esm/instrumentation.js

@@ -0,0 +1,82 @@
+import { handleMaybePromise, isPromise } from '@whatwg-node/promise-helpers';
+/**
+ * Composes 2 instrumentations together into one instrumentation.
+ * The first one will be the outer call, the second one the inner call.
+ */
+export function chain(first, next) {
+    const merged = { ...next, ...first };
+    for (const key of Object.keys(merged)) {
+        if (key in first && key in next) {
+            merged[key] = (payload, wrapped) => first[key](payload, () => next[key](payload, wrapped));
+        }
+    }
+    return merged;
+}
+/**
+ * Composes a list of instrumentation together into one instrumentation object.
+ * The order of execution will respect the order of the array,
+ * the first one being the outter most call, the last one the inner most call.
+ */
+export function composeInstrumentation(instrumentation) {
+    return instrumentation.length > 0 ? instrumentation.reduce(chain) : undefined;
+}
+/**
+ * Extract instrumentation from a list of plugins.
+ * It returns instrumentation found, and the list of plugins without their instrumentation.
+ *
+ * You can use this to easily customize the composition of the instrumentation if the default one
+ * doesn't suits your needs.
+ */
+export function getInstrumentationAndPlugin(plugins) {
+    const pluginInstrumentation = [];
+    const newPlugins = [];
+    for (const { instrumentation, ...plugin } of plugins) {
+        if (instrumentation) {
+            pluginInstrumentation.push(instrumentation);
+        }
+        newPlugins.push(plugin);
+    }
+    return { pluginInstrumentation, plugins: newPlugins };
+}
+/**
+ * A helper to instrument a function.
+ *
+ * @param payload: The first argument that will be passed to the instrumentation on each function call
+ * @returns Function and Async Functions factories allowing to wrap a function with a given instrument.
+ */
+export const getInstrumented = (payload) => ({
+    /**
+     * Wraps the `wrapped` function with the given `instrument` wrapper.
+     * @returns The wrapped function, or `undefined` if the instrument is `undefined`.
+     */
+    fn(instrument, wrapped) {
+        if (!instrument) {
+            return wrapped;
+        }
+        return (...args) => {
+            let result;
+            instrument(payload, () => {
+                result = wrapped(...args);
+            });
+            return result;
+        };
+    },
+    /**
+     * Wraps the `wrapped` function with the given `instrument` wrapper.
+     * @returns The wrapped function, or `undefined` if the instrument is `undefined`.
+     */
+    asyncFn(instrument, wrapped) {
+        if (!instrument) {
+            return wrapped;
+        }
+        return (...args) => {
+            let result;
+            return handleMaybePromise(() => instrument(payload, () => {
+                result = wrapped(...args);
+                return isPromise(result) ? result.then(() => undefined) : undefined;
+            }), () => {
+                return result;
+            });
+        };
+    },
+});

package/node_modules/@envelop/instrumentation/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@envelop/instrumentation",
+  "version": "1.0.0",
+  "sideEffects": false,
+  "dependencies": {
+    "@whatwg-node/promise-helpers": "^1.2.1",
+    "tslib": "^2.5.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/n1ru4l/envelop.git",
+    "directory": "packages/instrumentation"
+  },
+  "author": "Valentin Cocaud <v.cocaud@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./*": {
+      "require": {
+        "types": "./typings/*.d.cts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
+    },
+    "./package.json": "./package.json"
+  }
+}

package/node_modules/@envelop/instrumentation/typings/index.d.cts

@@ -0,0 +1 @@
+export * from './instrumentation.cjs';

package/node_modules/@envelop/instrumentation/typings/index.d.ts

@@ -0,0 +1 @@
+export * from './instrumentation.js';

package/node_modules/@envelop/instrumentation/typings/instrumentation.d.cts

@@ -0,0 +1,44 @@
+import { MaybePromise } from '@whatwg-node/promise-helpers';
+export type GenericInstrumentation = Record<string, (payload: any, wrapped: () => MaybePromise<void>) => MaybePromise<void>>;
+/**
+ * Composes 2 instrumentations together into one instrumentation.
+ * The first one will be the outer call, the second one the inner call.
+ */
+export declare function chain<First extends GenericInstrumentation, Next extends GenericInstrumentation>(first: First, next: Next): First & Next;
+/**
+ * Composes a list of instrumentation together into one instrumentation object.
+ * The order of execution will respect the order of the array,
+ * the first one being the outter most call, the last one the inner most call.
+ */
+export declare function composeInstrumentation<T extends GenericInstrumentation>(instrumentation: T[]): T | undefined;
+/**
+ * Extract instrumentation from a list of plugins.
+ * It returns instrumentation found, and the list of plugins without their instrumentation.
+ *
+ * You can use this to easily customize the composition of the instrumentation if the default one
+ * doesn't suits your needs.
+ */
+export declare function getInstrumentationAndPlugin<T, P extends {
+    instrumentation?: T;
+}>(plugins: P[]): {
+    pluginInstrumentation: T[];
+    plugins: Omit<P, 'instrumentation'>[];
+};
+/**
+ * A helper to instrument a function.
+ *
+ * @param payload: The first argument that will be passed to the instrumentation on each function call
+ * @returns Function and Async Functions factories allowing to wrap a function with a given instrument.
+ */
+export declare const getInstrumented: <TPayload>(payload: TPayload) => {
+    /**
+     * Wraps the `wrapped` function with the given `instrument` wrapper.
+     * @returns The wrapped function, or `undefined` if the instrument is `undefined`.
+     */
+    fn<TResult, TArgs extends any[]>(instrument: ((payload: TPayload, wrapped: () => void) => void) | undefined, wrapped: (...args: TArgs) => TResult): (...args: TArgs) => TResult;
+    /**
+     * Wraps the `wrapped` function with the given `instrument` wrapper.
+     * @returns The wrapped function, or `undefined` if the instrument is `undefined`.
+     */
+    asyncFn<TResult, TArgs_1 extends any[]>(instrument: ((payload: TPayload, wrapped: () => MaybePromise<void>) => MaybePromise<void>) | undefined, wrapped: (...args: TArgs_1) => MaybePromise<TResult>): (...args: TArgs_1) => MaybePromise<TResult>;
+};

package/node_modules/@envelop/instrumentation/typings/instrumentation.d.ts

@@ -0,0 +1,44 @@
+import { MaybePromise } from '@whatwg-node/promise-helpers';
+export type GenericInstrumentation = Record<string, (payload: any, wrapped: () => MaybePromise<void>) => MaybePromise<void>>;
+/**
+ * Composes 2 instrumentations together into one instrumentation.
+ * The first one will be the outer call, the second one the inner call.
+ */
+export declare function chain<First extends GenericInstrumentation, Next extends GenericInstrumentation>(first: First, next: Next): First & Next;
+/**
+ * Composes a list of instrumentation together into one instrumentation object.
+ * The order of execution will respect the order of the array,
+ * the first one being the outter most call, the last one the inner most call.
+ */
+export declare function composeInstrumentation<T extends GenericInstrumentation>(instrumentation: T[]): T | undefined;
+/**
+ * Extract instrumentation from a list of plugins.
+ * It returns instrumentation found, and the list of plugins without their instrumentation.
+ *
+ * You can use this to easily customize the composition of the instrumentation if the default one
+ * doesn't suits your needs.
+ */
+export declare function getInstrumentationAndPlugin<T, P extends {
+    instrumentation?: T;
+}>(plugins: P[]): {
+    pluginInstrumentation: T[];
+    plugins: Omit<P, 'instrumentation'>[];
+};
+/**
+ * A helper to instrument a function.
+ *
+ * @param payload: The first argument that will be passed to the instrumentation on each function call
+ * @returns Function and Async Functions factories allowing to wrap a function with a given instrument.
+ */
+export declare const getInstrumented: <TPayload>(payload: TPayload) => {
+    /**
+     * Wraps the `wrapped` function with the given `instrument` wrapper.
+     * @returns The wrapped function, or `undefined` if the instrument is `undefined`.
+     */
+    fn<TResult, TArgs extends any[]>(instrument: ((payload: TPayload, wrapped: () => void) => void) | undefined, wrapped: (...args: TArgs) => TResult): (...args: TArgs) => TResult;
+    /**
+     * Wraps the `wrapped` function with the given `instrument` wrapper.
+     * @returns The wrapped function, or `undefined` if the instrument is `undefined`.
+     */
+    asyncFn<TResult, TArgs_1 extends any[]>(instrument: ((payload: TPayload, wrapped: () => MaybePromise<void>) => MaybePromise<void>) | undefined, wrapped: (...args: TArgs_1) => MaybePromise<TResult>): (...args: TArgs_1) => MaybePromise<TResult>;
+};