@trpc/server 11.0.0-alpha-tmp-export-from-main.218 → 11.0.0-alpha-tmp-export-from-main-nuke-core.239

package/dist/http.d.ts

@@ -1,7 +1,2 @@
-export { getHTTPStatusCode, getHTTPStatusCodeFromError, } from './@trpc-core-unstable-do-not-import-this-please';
-export { resolveHTTPResponse } from './@trpc-core-unstable-do-not-import-this-please';
-export type { BaseHandlerOptions, HTTPBaseHandlerOptions, HTTPHeaders, HTTPRequest, HTTPResponse, OnErrorFunction, ProcedureCall, ResolveHTTPRequestOptionsContextFn, ResponseChunk, ResponseMeta, ResponseMetaFn, TRPCRequestInfo, } from './@trpc-core-unstable-do-not-import-this-please';
-export { getBatchStreamFormatter } from './@trpc-core-unstable-do-not-import-this-please';
-export type { BaseContentTypeHandler, BodyResult, } from './@trpc-core-unstable-do-not-import-this-please';
-export { getJsonContentTypeInputs } from './@trpc-core-unstable-do-not-import-this-please';
+export * from './@trpc/server/http';
 //# sourceMappingURL=http.d.ts.map

package/dist/http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,0BAA0B,GAC3B,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AACtF,YAAY,EACV,kBAAkB,EAClB,sBAAsB,EACtB,WAAW,EACX,WAAW,EACX,YAAY,EACZ,eAAe,EACf,aAAa,EACb,kCAAkC,EAClC,aAAa,EACb,YAAY,EACZ,cAAc,EACd,eAAe,GAChB,MAAM,iDAAiD,CAAC;AAEzD,OAAO,EAAE,uBAAuB,EAAE,MAAM,iDAAiD,CAAC;AAC1F,YAAY,EACV,sBAAsB,EACtB,UAAU,GACX,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,iDAAiD,CAAC"}
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/http.js

@@ -1,26 +1,16 @@
 'use strict';
 
-var core = require('@trpc/core');
+var getHTTPStatusCode = require('./unstable-core-do-not-import/http/getHTTPStatusCode.js');
+require('./unstable-core-do-not-import/rpc/codes.js');
+require('./unstable-core-do-not-import/rootConfig.js');
+var resolveHTTPResponse = require('./unstable-core-do-not-import/http/resolveHTTPResponse.js');
+var batchStreamFormatter = require('./unstable-core-do-not-import/http/batchStreamFormatter.js');
+var contentType = require('./unstable-core-do-not-import/http/contentType.js');
 
 
 
-Object.defineProperty(exports, "getBatchStreamFormatter", {
-  enumerable: true,
-  get: function () { return core.getBatchStreamFormatter; }
-});
-Object.defineProperty(exports, "getHTTPStatusCode", {
-  enumerable: true,
-  get: function () { return core.getHTTPStatusCode; }
-});
-Object.defineProperty(exports, "getHTTPStatusCodeFromError", {
-  enumerable: true,
-  get: function () { return core.getHTTPStatusCodeFromError; }
-});
-Object.defineProperty(exports, "getJsonContentTypeInputs", {
-  enumerable: true,
-  get: function () { return core.getJsonContentTypeInputs; }
-});
-Object.defineProperty(exports, "resolveHTTPResponse", {
-  enumerable: true,
-  get: function () { return core.resolveHTTPResponse; }
-});
+exports.getHTTPStatusCode = getHTTPStatusCode.getHTTPStatusCode;
+exports.getHTTPStatusCodeFromError = getHTTPStatusCode.getHTTPStatusCodeFromError;
+exports.resolveHTTPResponse = resolveHTTPResponse.resolveHTTPResponse;
+exports.getBatchStreamFormatter = batchStreamFormatter.getBatchStreamFormatter;
+exports.getJsonContentTypeInputs = contentType.getJsonContentTypeInputs;

package/dist/http.mjs

@@ -1 +1,6 @@
-export { getBatchStreamFormatter, getHTTPStatusCode, getHTTPStatusCodeFromError, getJsonContentTypeInputs, resolveHTTPResponse } from '@trpc/core';
+export { getHTTPStatusCode, getHTTPStatusCodeFromError } from './unstable-core-do-not-import/http/getHTTPStatusCode.mjs';
+import './unstable-core-do-not-import/rpc/codes.mjs';
+import './unstable-core-do-not-import/rootConfig.mjs';
+export { resolveHTTPResponse } from './unstable-core-do-not-import/http/resolveHTTPResponse.mjs';
+export { getBatchStreamFormatter } from './unstable-core-do-not-import/http/batchStreamFormatter.mjs';
+export { getJsonContentTypeInputs } from './unstable-core-do-not-import/http/contentType.mjs';

package/dist/index.d.ts

@@ -1,69 +1,2 @@
-export { TRPCError, 
-/**
- * @deprecated use `experimental_trpcMiddleware` instead
- */
-experimental_standaloneMiddleware, experimental_standaloneMiddleware as experimental_trpcMiddleware, initTRPC, callProcedure as callTRPCProcedure, getTRPCErrorFromUnknown, transformTRPCResponse, createFlatProxy as createTRPCFlatProxy, type inferProcedureInput, type inferProcedureOutput, type inferRouterError, type inferRouterInputs, type inferRouterOutputs, type inferRouterContext, type inferTransformedProcedureOutput, type inferTransformedSubscriptionOutput, type AnyProcedure as AnyTRPCProcedure, type AnyRouter as AnyTRPCRouter, type AnyMiddlewareFunction as AnyTRPCMiddlewareFunction, type CombinedDataTransformer as TRPCCombinedDataTransformer, type ProcedureType as TRPCProcedureType, type AnyMutationProcedure as AnyTRPCMutationProcedure, type AnyQueryProcedure as AnyTRPCQueryProcedure, type ProcedureRouterRecord as TRPCProcedureRouterRecord, type ProcedureArgs as TRPCProcedureArgs, type AnySubscriptionProcedure as AnyTRPCSubscriptionProcedure, } from './@trpc-core-unstable-do-not-import-this-please';
-export type { 
-/**
- * @deprecated use `AnyTRPCProcedure` instead
- */
-AnyProcedure, 
-/**
- * @deprecated use `AnyTRPCRouter` instead
- */
-AnyRouter, 
-/**
- * @deprecated use `AnyTRPCMiddlewareFunction` instead
- */
-AnyMiddlewareFunction, 
-/**
- * @deprecated use `TRPCCombinedDataTransformer` instead
- */
-CombinedDataTransformer, 
-/**
- * @deprecated This is a utility type will be removed in v12
- */
-Dict, 
-/**
- * @deprecated This is a utility type will be removed in v12
- */
-DeepPartial, 
-/**
- * @deprecated use `TRPCProcedureType` instead
- */
-ProcedureType, 
-/**
- * @deprecated use `AnyTRPCMutationProcedure` instead
- */
-AnyMutationProcedure, 
-/**
- * @deprecated use `AnyTRPCQueryProcedure` instead
- */
-AnyQueryProcedure, 
-/**
- * @deprecated use `TRPCProcedureRouterRecord` instead
- */
-ProcedureRouterRecord, 
-/**
- * @deprecated use `TRPCProcedureArgs` instead
- */
-ProcedureArgs, 
-/**
- * @deprecated use `AnyTRPCSubscriptionProcedure` instead
- */
-AnySubscriptionProcedure, } from '@trpc/core';
-export { 
-/**
- * @deprecated use `getTRPCErrorShape` instead
- */
-getErrorShape, 
-/**
- * @deprecated use `callTRPCProcedure` instead
- */
-callProcedure, } from '@trpc/core';
-/**
- * @deprecated
- * Use `Awaited<ReturnType<typeof myFunction>>` instead
- */
-export type inferAsyncReturnType<TFunction extends (...args: any[]) => any> = Awaited<ReturnType<TFunction>>;
+export * from './@trpc/server';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS;AACT;;GAEG;AACH,iCAAiC,EACjC,iCAAiC,IAAI,2BAA2B,EAChE,QAAQ,EAER,aAAa,IAAI,iBAAiB,EAClC,uBAAuB,EACvB,qBAAqB,EACrB,eAAe,IAAI,mBAAmB,EACtC,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,+BAA+B,EACpC,KAAK,kCAAkC,EACvC,KAAK,YAAY,IAAI,gBAAgB,EACrC,KAAK,SAAS,IAAI,aAAa,EAC/B,KAAK,qBAAqB,IAAI,yBAAyB,EACvD,KAAK,uBAAuB,IAAI,2BAA2B,EAC3D,KAAK,aAAa,IAAI,iBAAiB,EACvC,KAAK,oBAAoB,IAAI,wBAAwB,EACrD,KAAK,iBAAiB,IAAI,qBAAqB,EAC/C,KAAK,qBAAqB,IAAI,yBAAyB,EACvD,KAAK,aAAa,IAAI,iBAAiB,EACvC,KAAK,wBAAwB,IAAI,4BAA4B,GAC9D,MAAM,iDAAiD,CAAC;AAEzD,YAAY;AACV;;GAEG;AACH,YAAY;AACZ;;GAEG;AACH,SAAS;AACT;;GAEG;AACH,qBAAqB;AACrB;;GAEG;AACH,uBAAuB;AAEvB;;GAEG;AACH,IAAI;AAEJ;;GAEG;AACH,WAAW;AACX;;GAEG;AACH,aAAa;AACb;;GAEG;AACH,oBAAoB;AAEpB;;GAEG;AACH,iBAAiB;AACjB;;GAEG;AACH,qBAAqB;AACrB;;GAEG;AACH,aAAa;AACb;;GAEG;AACH,wBAAwB,GACzB,MAAM,YAAY,CAAC;AAEpB,OAAO;AACL;;GAEG;AACH,aAAa;AAEb;;GAEG;AACH,aAAa,GACd,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,MAAM,MAAM,oBAAoB,CAAC,SAAS,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,IACxE,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -1,46 +1,23 @@
 'use strict';
 
-var core = require('@trpc/core');
+var getErrorShape = require('./unstable-core-do-not-import/error/getErrorShape.js');
+var TRPCError = require('./unstable-core-do-not-import/error/TRPCError.js');
+var initTRPC = require('./unstable-core-do-not-import/initTRPC.js');
+var middleware = require('./unstable-core-do-not-import/middleware.js');
+var router = require('./unstable-core-do-not-import/router.js');
+var transformer = require('./unstable-core-do-not-import/transformer.js');
+var createProxy = require('./unstable-core-do-not-import/createProxy.js');
+require('./unstable-core-do-not-import/rpc/codes.js');
 
 
 
-Object.defineProperty(exports, "TRPCError", {
-  enumerable: true,
-  get: function () { return core.TRPCError; }
-});
-Object.defineProperty(exports, "callProcedure", {
-  enumerable: true,
-  get: function () { return core.callProcedure; }
-});
-Object.defineProperty(exports, "callTRPCProcedure", {
-  enumerable: true,
-  get: function () { return core.callProcedure; }
-});
-Object.defineProperty(exports, "createTRPCFlatProxy", {
-  enumerable: true,
-  get: function () { return core.createFlatProxy; }
-});
-Object.defineProperty(exports, "experimental_standaloneMiddleware", {
-  enumerable: true,
-  get: function () { return core.experimental_standaloneMiddleware; }
-});
-Object.defineProperty(exports, "experimental_trpcMiddleware", {
-  enumerable: true,
-  get: function () { return core.experimental_standaloneMiddleware; }
-});
-Object.defineProperty(exports, "getErrorShape", {
-  enumerable: true,
-  get: function () { return core.getErrorShape; }
-});
-Object.defineProperty(exports, "getTRPCErrorFromUnknown", {
-  enumerable: true,
-  get: function () { return core.getTRPCErrorFromUnknown; }
-});
-Object.defineProperty(exports, "initTRPC", {
-  enumerable: true,
-  get: function () { return core.initTRPC; }
-});
-Object.defineProperty(exports, "transformTRPCResponse", {
-  enumerable: true,
-  get: function () { return core.transformTRPCResponse; }
-});
+exports.getErrorShape = getErrorShape.getErrorShape;
+exports.TRPCError = TRPCError.TRPCError;
+exports.getTRPCErrorFromUnknown = TRPCError.getTRPCErrorFromUnknown;
+exports.initTRPC = initTRPC.initTRPC;
+exports.experimental_standaloneMiddleware = middleware.experimental_standaloneMiddleware;
+exports.experimental_trpcMiddleware = middleware.experimental_standaloneMiddleware;
+exports.callProcedure = router.callProcedure;
+exports.callTRPCProcedure = router.callProcedure;
+exports.transformTRPCResponse = transformer.transformTRPCResponse;
+exports.createTRPCFlatProxy = createProxy.createFlatProxy;

package/dist/index.mjs

@@ -1 +1,8 @@
-export { TRPCError, callProcedure, callProcedure as callTRPCProcedure, createFlatProxy as createTRPCFlatProxy, experimental_standaloneMiddleware, experimental_standaloneMiddleware as experimental_trpcMiddleware, getErrorShape, getTRPCErrorFromUnknown, initTRPC, transformTRPCResponse } from '@trpc/core';
+export { getErrorShape } from './unstable-core-do-not-import/error/getErrorShape.mjs';
+export { TRPCError, getTRPCErrorFromUnknown } from './unstable-core-do-not-import/error/TRPCError.mjs';
+export { initTRPC } from './unstable-core-do-not-import/initTRPC.mjs';
+export { experimental_standaloneMiddleware, experimental_standaloneMiddleware as experimental_trpcMiddleware } from './unstable-core-do-not-import/middleware.mjs';
+export { callProcedure, callProcedure as callTRPCProcedure } from './unstable-core-do-not-import/router.mjs';
+export { transformTRPCResponse } from './unstable-core-do-not-import/transformer.mjs';
+export { createFlatProxy as createTRPCFlatProxy } from './unstable-core-do-not-import/createProxy.mjs';
+import './unstable-core-do-not-import/rpc/codes.mjs';

package/dist/observable/index.d.ts

@@ -0,0 +1,5 @@
+export type { inferObservableValue } from './observable';
+export { isObservable, observable, observableToPromise } from './observable';
+export { map, share, tap } from './operators';
+export type { Observable, Observer, TeardownLogic, Unsubscribable, UnsubscribeFn, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/observable/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/observable/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAC9C,YAAY,EACV,UAAU,EACV,QAAQ,EACR,aAAa,EACb,cAAc,EACd,aAAa,GACd,MAAM,SAAS,CAAC"}

package/dist/observable/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var observable = require('./observable.js');
+var operators = require('./operators.js');
+
+
+
+exports.isObservable = observable.isObservable;
+exports.observable = observable.observable;
+exports.observableToPromise = observable.observableToPromise;
+exports.map = operators.map;
+exports.share = operators.share;
+exports.tap = operators.tap;

package/dist/observable/index.mjs

@@ -0,0 +1,2 @@
+export { isObservable, observable, observableToPromise } from './observable.mjs';
+export { map, share, tap } from './operators.mjs';

package/dist/observable/observable.d.ts

@@ -0,0 +1,13 @@
+import type { Observable, Observer, TeardownLogic } from './types';
+/** @public */
+export type inferObservableValue<TObservable> = TObservable extends Observable<infer TValue, unknown> ? TValue : never;
+/** @public */
+export declare function isObservable(x: unknown): x is Observable<unknown, unknown>;
+/** @public */
+export declare function observable<TValue, TError = unknown>(subscribe: (observer: Observer<TValue, TError>) => TeardownLogic): Observable<TValue, TError>;
+/** @internal */
+export declare function observableToPromise<TValue>(observable: Observable<TValue, unknown>): {
+    promise: Promise<TValue>;
+    abort: () => void;
+};
+//# sourceMappingURL=observable.d.ts.map

package/dist/observable/observable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable.d.ts","sourceRoot":"","sources":["../../src/observable/observable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,QAAQ,EAER,aAAa,EAEd,MAAM,SAAS,CAAC;AAMjB,cAAc;AACd,MAAM,MAAM,oBAAoB,CAAC,WAAW,IAAI,WAAW,SAAS,UAAU,CAC5E,MAAM,MAAM,EACZ,OAAO,CACR,GACG,MAAM,GACN,KAAK,CAAC;AAEV,cAAc;AACd,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAE1E;AAED,cAAc;AACd,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,EACjD,SAAS,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,aAAa,GAC/D,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CA6D5B;AA8BD,gBAAgB;AAChB,wBAAgB,mBAAmB,CAAC,MAAM,EACxC,UAAU,EAAE,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC;;iBAEtB,IAAI;EAkCtB"}

package/dist/observable/observable.js

@@ -0,0 +1,126 @@
+'use strict';
+
+function identity(x) {
+    return x;
+}
+/** @public */ function isObservable(x) {
+    return typeof x === 'object' && x !== null && 'subscribe' in x;
+}
+/** @public */ function observable(subscribe) {
+    const self = {
+        subscribe (observer) {
+            let teardownRef = null;
+            let isDone = false;
+            let unsubscribed = false;
+            let teardownImmediately = false;
+            function unsubscribe() {
+                if (teardownRef === null) {
+                    teardownImmediately = true;
+                    return;
+                }
+                if (unsubscribed) {
+                    return;
+                }
+                unsubscribed = true;
+                if (typeof teardownRef === 'function') {
+                    teardownRef();
+                } else if (teardownRef) {
+                    teardownRef.unsubscribe();
+                }
+            }
+            teardownRef = subscribe({
+                next (value) {
+                    if (isDone) {
+                        return;
+                    }
+                    observer.next?.(value);
+                },
+                error (err) {
+                    if (isDone) {
+                        return;
+                    }
+                    isDone = true;
+                    observer.error?.(err);
+                    unsubscribe();
+                },
+                complete () {
+                    if (isDone) {
+                        return;
+                    }
+                    isDone = true;
+                    observer.complete?.();
+                    unsubscribe();
+                }
+            });
+            if (teardownImmediately) {
+                unsubscribe();
+            }
+            return {
+                unsubscribe
+            };
+        },
+        pipe (...operations) {
+            return pipeFromArray(operations)(self);
+        }
+    };
+    return self;
+}
+function pipeFromArray(fns) {
+    if (fns.length === 0) {
+        return identity;
+    }
+    if (fns.length === 1) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return fns[0];
+    }
+    return function piped(input) {
+        return fns.reduce((prev, fn)=>fn(prev), input);
+    };
+}
+class ObservableAbortError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'ObservableAbortError';
+        Object.setPrototypeOf(this, ObservableAbortError.prototype);
+    }
+}
+/** @internal */ function observableToPromise(observable) {
+    let abort;
+    const promise = new Promise((resolve, reject)=>{
+        let isDone = false;
+        function onDone() {
+            if (isDone) {
+                return;
+            }
+            isDone = true;
+            reject(new ObservableAbortError('This operation was aborted.'));
+            obs$.unsubscribe();
+        }
+        const obs$ = observable.subscribe({
+            next (data) {
+                isDone = true;
+                resolve(data);
+                onDone();
+            },
+            error (data) {
+                isDone = true;
+                reject(data);
+                onDone();
+            },
+            complete () {
+                isDone = true;
+                onDone();
+            }
+        });
+        abort = onDone;
+    });
+    return {
+        promise,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        abort: abort
+    };
+}
+
+exports.isObservable = isObservable;
+exports.observable = observable;
+exports.observableToPromise = observableToPromise;

package/dist/observable/observable.mjs

@@ -0,0 +1,122 @@
+function identity(x) {
+    return x;
+}
+/** @public */ function isObservable(x) {
+    return typeof x === 'object' && x !== null && 'subscribe' in x;
+}
+/** @public */ function observable(subscribe) {
+    const self = {
+        subscribe (observer) {
+            let teardownRef = null;
+            let isDone = false;
+            let unsubscribed = false;
+            let teardownImmediately = false;
+            function unsubscribe() {
+                if (teardownRef === null) {
+                    teardownImmediately = true;
+                    return;
+                }
+                if (unsubscribed) {
+                    return;
+                }
+                unsubscribed = true;
+                if (typeof teardownRef === 'function') {
+                    teardownRef();
+                } else if (teardownRef) {
+                    teardownRef.unsubscribe();
+                }
+            }
+            teardownRef = subscribe({
+                next (value) {
+                    if (isDone) {
+                        return;
+                    }
+                    observer.next?.(value);
+                },
+                error (err) {
+                    if (isDone) {
+                        return;
+                    }
+                    isDone = true;
+                    observer.error?.(err);
+                    unsubscribe();
+                },
+                complete () {
+                    if (isDone) {
+                        return;
+                    }
+                    isDone = true;
+                    observer.complete?.();
+                    unsubscribe();
+                }
+            });
+            if (teardownImmediately) {
+                unsubscribe();
+            }
+            return {
+                unsubscribe
+            };
+        },
+        pipe (...operations) {
+            return pipeFromArray(operations)(self);
+        }
+    };
+    return self;
+}
+function pipeFromArray(fns) {
+    if (fns.length === 0) {
+        return identity;
+    }
+    if (fns.length === 1) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return fns[0];
+    }
+    return function piped(input) {
+        return fns.reduce((prev, fn)=>fn(prev), input);
+    };
+}
+class ObservableAbortError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'ObservableAbortError';
+        Object.setPrototypeOf(this, ObservableAbortError.prototype);
+    }
+}
+/** @internal */ function observableToPromise(observable) {
+    let abort;
+    const promise = new Promise((resolve, reject)=>{
+        let isDone = false;
+        function onDone() {
+            if (isDone) {
+                return;
+            }
+            isDone = true;
+            reject(new ObservableAbortError('This operation was aborted.'));
+            obs$.unsubscribe();
+        }
+        const obs$ = observable.subscribe({
+            next (data) {
+                isDone = true;
+                resolve(data);
+                onDone();
+            },
+            error (data) {
+                isDone = true;
+                reject(data);
+                onDone();
+            },
+            complete () {
+                isDone = true;
+                onDone();
+            }
+        });
+        abort = onDone;
+    });
+    return {
+        promise,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        abort: abort
+    };
+}
+
+export { isObservable, observable, observableToPromise };

package/dist/observable/operators.d.ts

@@ -0,0 +1,8 @@
+import type { MonoTypeOperatorFunction, Observer, OperatorFunction } from './types';
+export declare function map<TValueBefore, TError, TValueAfter>(project: (value: TValueBefore, index: number) => TValueAfter): OperatorFunction<TValueBefore, TError, TValueAfter, TError>;
+interface ShareConfig {
+}
+export declare function share<TValue, TError>(_opts?: ShareConfig): MonoTypeOperatorFunction<TValue, TError>;
+export declare function tap<TValue, TError>(observer: Partial<Observer<TValue, TError>>): MonoTypeOperatorFunction<TValue, TError>;
+export {};
+//# sourceMappingURL=operators.d.ts.map

package/dist/observable/operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../../src/observable/operators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,QAAQ,EACR,gBAAgB,EAEjB,MAAM,SAAS,CAAC;AAEjB,wBAAgB,GAAG,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EACnD,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,KAAK,WAAW,GAC3D,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,CAoB7D;AAED,UAAU,WAAW;CAAG;AACxB,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,EAClC,KAAK,CAAC,EAAE,WAAW,GAClB,wBAAwB,CAAC,MAAM,EAAE,MAAM,CAAC,CA2D1C;AAED,wBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,EAChC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC1C,wBAAwB,CAAC,MAAM,EAAE,MAAM,CAAC,CAqB1C"}

package/dist/observable/operators.js

@@ -0,0 +1,103 @@
+'use strict';
+
+function map(project) {
+    return (originalObserver)=>{
+        return {
+            subscribe (observer) {
+                let index = 0;
+                const subscription = originalObserver.subscribe({
+                    next (value) {
+                        observer.next?.(project(value, index++));
+                    },
+                    error (error) {
+                        observer.error?.(error);
+                    },
+                    complete () {
+                        observer.complete?.();
+                    }
+                });
+                return subscription;
+            }
+        };
+    };
+}
+function share(_opts) {
+    return (originalObserver)=>{
+        let refCount = 0;
+        let subscription = null;
+        const observers = [];
+        function startIfNeeded() {
+            if (subscription) {
+                return;
+            }
+            subscription = originalObserver.subscribe({
+                next (value) {
+                    for (const observer of observers){
+                        observer.next?.(value);
+                    }
+                },
+                error (error) {
+                    for (const observer of observers){
+                        observer.error?.(error);
+                    }
+                },
+                complete () {
+                    for (const observer of observers){
+                        observer.complete?.();
+                    }
+                }
+            });
+        }
+        function resetIfNeeded() {
+            // "resetOnRefCountZero"
+            if (refCount === 0 && subscription) {
+                const _sub = subscription;
+                subscription = null;
+                _sub.unsubscribe();
+            }
+        }
+        return {
+            subscribe (observer) {
+                refCount++;
+                observers.push(observer);
+                startIfNeeded();
+                return {
+                    unsubscribe () {
+                        refCount--;
+                        resetIfNeeded();
+                        const index = observers.findIndex((v)=>v === observer);
+                        if (index > -1) {
+                            observers.splice(index, 1);
+                        }
+                    }
+                };
+            }
+        };
+    };
+}
+function tap(observer) {
+    return (originalObserver)=>{
+        return {
+            subscribe (observer2) {
+                return originalObserver.subscribe({
+                    next (v) {
+                        observer.next?.(v);
+                        observer2.next?.(v);
+                    },
+                    error (v) {
+                        observer.error?.(v);
+                        observer2.error?.(v);
+                    },
+                    complete () {
+                        observer.complete?.();
+                        observer2.complete?.();
+                    }
+                });
+            }
+        };
+    };
+}
+
+exports.map = map;
+exports.share = share;
+exports.tap = tap;