@youngspe/async-scope 0.1.0-dev.0 → 0.1.0-dev.1

package/dist/scope/context.js

@@ -0,0 +1,71 @@
+const contextProps = {
+    resources: undefined,
+    scope: undefined,
+    signal: undefined,
+    token: undefined,
+};
+export class ContextData {
+    #descriptors;
+    constructor(descriptors) {
+        this.#descriptors = descriptors;
+    }
+    updateContext(target) {
+        if (this.#descriptors) {
+            const descriptors = this.#descriptors;
+            for (const key of [...Object.keys(descriptors), ...Object.getOwnPropertySymbols(descriptors)]) {
+                const descriptor = descriptors[key];
+                if (!descriptor || key in contextProps)
+                    continue;
+                Object.defineProperty(target, key, descriptor);
+            }
+        }
+        return target;
+    }
+    builder() {
+        return new ContextData.#Builder(Object.assign({}, this.#descriptors));
+    }
+    static builder() {
+        return new ContextData.#Builder(undefined);
+    }
+    static empty = Object.freeze(new ContextData(undefined));
+    static #Builder = class Builder {
+        #builderDescriptors;
+        constructor(descriptors) {
+            this.#builderDescriptors = descriptors;
+        }
+        values(props) {
+            const descriptors = (this.#builderDescriptors ??= {});
+            for (const key of [...Object.keys(props), ...Object.getOwnPropertySymbols(props)]) {
+                const value = props[key];
+                if (value === undefined)
+                    continue;
+                descriptors[key] = { value };
+            }
+            return this;
+        }
+        getters(getters) {
+            const descriptors = (this.#builderDescriptors ??= {});
+            for (const key of [...Object.keys(getters), ...Object.getOwnPropertySymbols(getters)]) {
+                const value = getters[key];
+                if (value === undefined)
+                    continue;
+                descriptors[key] = {
+                    get() {
+                        return value(this);
+                    },
+                };
+            }
+            return this;
+        }
+        merge(contextData) {
+            Object.assign((this.#builderDescriptors ??= {}), contextData.#descriptors);
+            return this;
+        }
+        finish() {
+            if (!this.#builderDescriptors)
+                return ContextData.empty;
+            return new ContextData(this.#builderDescriptors);
+        }
+    };
+}
+//# sourceMappingURL=context.js.map

package/dist/scope/from.d.ts

@@ -1,3 +1,3 @@
 import { Scope, type ToScope } from '../scope.ts';
-export declare function scopeFrom(src: ToScope, onError?: (error: unknown) => void): Scope;
+export declare function scopeFrom<V extends object = object>(src: ToScope<V>, onError?: (error: unknown) => void): Scope<V>;
 //# sourceMappingURL=from.d.ts.map

package/dist/scope/from.js

@@ -1,13 +1,27 @@
 import { Token } from '../token.js';
 import { Scope, STATIC_SCOPE, StandardScope } from '../scope.js';
-import { isArray } from '../utils.js';
 import { ScopedResources } from '../scopedResource.js';
+import { isIterable } from '@youngspe/common-async-utils';
+import { ContextData } from './context.js';
+import { CancellationTokenBase, ScopeBase } from '@youngspe/async-scope-common';
+function combineContextData(values) {
+    const firstResult = values.next();
+    if (firstResult.done)
+        return undefined;
+    const first = firstResult.value;
+    let builder;
+    for (const item of values) {
+        builder ??= first.builder();
+        builder.merge(item);
+    }
+    return builder?.finish() ?? first;
+}
 export function scopeFrom(src, onError) {
     if (!src)
         return STATIC_SCOPE;
-    if (src instanceof Scope)
+    if (src instanceof ScopeBase)
         return src;
-    if (src instanceof Token)
+    if (src instanceof CancellationTokenBase)
         return new StandardScope({ token: src, onError });
     if (src instanceof AbortSignal) {
         return new StandardScope({ token: Token.fromAbortSignal(src, { onError }), onError });
@@ -17,12 +31,15 @@ export function scopeFrom(src, onError) {
     const tokens = new Set();
     const abortSignals = new Set();
     const resources = new Set();
-    function flatten(src) {
-        if (!src)
+    const contextData = new Set();
+    function flatten(src, includeScope) {
+        if (!src || typeof src !== 'object')
             return;
-        if (src instanceof Scope) {
+        if (src instanceof Scope && includeScope) {
             if (src.token.isCancelled)
                 return src.token;
+            if (src === STATIC_SCOPE)
+                return;
             scopes.add(src);
             if (!src.token.isDefused) {
                 tokens.add(src.token);
@@ -30,6 +47,9 @@ export function scopeFrom(src, onError) {
             if (!src.resources.isEmpty) {
                 resources.add(src.resources);
             }
+            if (src.contextData !== ContextData.empty) {
+                contextData.add(src.contextData);
+            }
             return;
         }
         if (src instanceof Token) {
@@ -48,17 +68,17 @@ export function scopeFrom(src, onError) {
             abortSignals.add(src);
             return;
         }
-        if (isArray(src) || src instanceof Set) {
+        if (isIterable(src)) {
             for (const child of src) {
-                const cancelled = flatten(child);
+                const cancelled = flatten(child, includeScope);
                 if (cancelled)
                     return cancelled;
             }
             return;
         }
-        return flatten(src.scope) || flatten(src.token) || flatten(src.signal);
+        return flatten(src.scope, true) || flatten(src.token, false) || flatten(src.signal, false);
     }
-    const cancelled = flatten(src);
+    const cancelled = flatten(src, true);
     if (!hasNonScopeToken && scopes.size <= 1) {
         // If only one scope was passed in with no other tokens, we can return the
         // scope directly.
@@ -67,7 +87,7 @@ export function scopeFrom(src, onError) {
         //
         const [scope] = scopes;
         if (!cancelled || scope?.token === cancelled)
-            return scope ?? Scope.static;
+            return (scope ?? STATIC_SCOPE);
     }
     if (cancelled)
         return new StandardScope({ token: cancelled });
@@ -81,6 +101,7 @@ export function scopeFrom(src, onError) {
     return new StandardScope({
         token: Token.combine(tokens),
         resources: ScopedResources.combine(resources),
+        contextData: combineContextData(contextData.values()),
         onError,
     });
 }

package/dist/scope/standard.d.ts

@@ -1,14 +1,17 @@
 import { Token } from '../token.ts';
 import { Scope } from '../scope.ts';
 import { ScopedResources } from '../scopedResource.js';
-export declare class StandardScope extends Scope {
+import { ContextData } from './context.ts';
+export declare class StandardScope<V extends object> extends Scope<V> {
     #private;
     get token(): Token;
     get resources(): ScopedResources;
+    get contextData(): ContextData<V>;
     protected _onError(value: unknown): void;
     constructor(params: {
         token?: Token | undefined;
         resources?: ScopedResources | undefined;
+        contextData?: ContextData<V> | undefined;
         onError?: ((e: unknown) => void) | undefined;
     });
 }

package/dist/scope/standard.js

@@ -1,16 +1,21 @@
 import { Token } from '../token.js';
 import { Scope } from '../scope.js';
 import { ScopedResources } from '../scopedResource.js';
+import { ContextData } from './context.js';
 export class StandardScope extends Scope {
     #resources;
     #token;
     #onError;
+    #contextData;
     get token() {
         return this.#token;
     }
     get resources() {
         return this.#resources;
     }
+    get contextData() {
+        return this.#contextData ?? super.contextData;
+    }
     _onError(value) {
         return this.#onError ? this.#onError(value) : super._onError(value);
     }
@@ -18,6 +23,7 @@ export class StandardScope extends Scope {
         super();
         this.#token = params.token ?? Token.static;
         this.#resources = (params.token?.isCancelled ? undefined : params.resources) ?? ScopedResources.empty;
+        this.#contextData = params.token?.isCancelled ? undefined : params.contextData;
         this.#onError = params.onError;
     }
 }

package/dist/scope.d.ts

@@ -1,4 +1,4 @@
 export { Scope, STATIC_SCOPE } from './scope/base.ts';
 export { StandardScope } from './scope/standard.ts';
-export type { CommonScopeOptions, ScopeContext, ScopeRunOptions, ToScope } from './scope/base.ts';
+export type { CommonScopeOptions, ScopeContext, ScopeLaunchOptions as ScopeRunOptions, ToScope, } from './scope/base.ts';
 //# sourceMappingURL=scope.d.ts.map

package/dist/scopedResource.js

@@ -1,6 +1,5 @@
-import { joinPromises } from './join.js';
+import { isAsyncDisposable, isDisposable, joinPromises } from '@youngspe/common-async-utils';
 import { Scope } from './scope.js';
-import { isAsyncDisposable, isDisposable } from './utils.js';
 export class ResourceError extends Error {
     static {
         this.prototype.name = this.name;

package/dist/timers.d.ts

@@ -0,0 +1,23 @@
+import type { CancellableOptions } from './cancel.ts';
+declare const _timerId: unique symbol;
+interface _TimerId {
+    [_timerId]: typeof _timerId;
+}
+type TimerId = typeof globalThis extends {
+    setTimeout(...args: any): infer X;
+} ? X : _TimerId;
+type SetTimerFunction = <A extends any[] = []>(action: (...args: A) => void, ms: number, ...args: A) => TimerId;
+type ClearTimerFunction = (id: TimerId | undefined) => void;
+export interface Clock {
+    setTimeout: SetTimerFunction;
+    setInterval: SetTimerFunction;
+    clearTimeout: ClearTimerFunction;
+    clearInterval: ClearTimerFunction;
+}
+export declare const GlobalClock: Clock;
+export interface TimerOptions extends CancellableOptions {
+    clock?: Clock | undefined;
+}
+export declare function delay(ms: number, options?: TimerOptions): Promise<void>;
+export {};
+//# sourceMappingURL=timers.d.ts.map

package/dist/{timer.js → timers.js}

@@ -1,8 +1,6 @@
 import { Token } from './token.js';
-const GlobalClock = {
-    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+export const GlobalClock = {
     setTimeout: (f, ...args) => globalThis.setTimeout(f, ...args),
-    // eslint-disable-next-line @typescript-eslint/no-implied-eval
     setInterval: (f, ...args) => globalThis.setInterval(f, ...args),
     clearTimeout: id => globalThis.clearTimeout(id),
     clearInterval: id => globalThis.clearInterval(id),
@@ -25,4 +23,4 @@ export function delay(ms, options) {
         }, ms);
     });
 }
-//# sourceMappingURL=timer.js.map
+//# sourceMappingURL=timers.js.map

package/dist/token/base.d.ts

@@ -1,8 +1,14 @@
+import { CancellationTokenBase } from '@youngspe/async-scope-common';
 import type { CancellableOrDisposable, CancellableLike, CancellationListener, Cancellable } from '../cancel.ts';
 import type { Awaitable, Falsy } from '../types.ts';
 import { Subscription, type SubscriptionLifecycle } from '../events/sub.js';
 import type { ToScope } from '../scope.ts';
-export declare abstract class Token {
+export interface AddCancellableOptions {
+    paused?: boolean | undefined;
+    passive?: boolean | undefined;
+}
+export type ErrorFilter = (this: void, error: Error) => true | Error | 'defuse' | Falsy;
+export declare abstract class Token extends CancellationTokenBase {
     #private;
     /**
      * The reason for the cancellation if this token has already been cancelled, otherwise `undefined`.
@@ -13,7 +19,7 @@ export declare abstract class Token {
     /** If `true`, this token has been _defused_, meaning it is guaranteed never to be cancelled. */
     get isDefused(): boolean;
     /**
-     * If `true`, this token has been _cancelled_, and trigger any additional listeners.
+     * If `true`, this token has been _cancelled_, and will not trigger any additional listeners.
      *
      * This is equivalent to `token.error !== undefined`
      *
@@ -32,26 +38,25 @@ export declare abstract class Token {
      * - `undefined` if the listener could not be safely added. This is typically due to the token being
      *   cancelled and indicates any future attempts will also fail.
      */
-    protected abstract addOne(listener: CancellableOrDisposable): Subscription | undefined;
+    protected abstract addOne(listener: CancellableOrDisposable, options?: AddCancellableOptions): Subscription | undefined;
     /**
      * Adds listeners
      *
-     * @param listeners - listeners that should be added to this token.
-     * Each parameter may be:
-     * - A {@link CancellableLike}:
-     *   - A {@link Cancellable}
-     *   - A {@link Disposable}
-     *   - An {@link AsyncDisposable}
-     *   - A falsy value, which will be ignored
-     *   - A (possibly nested) array of any of the above.
+     * @param listener - a listener that should be added to this token.
+     * This may be:
+     * - A {@link Cancellable}
+     * - A {@link Disposable}
+     * - An {@link AsyncDisposable}
+     * - A falsy value, which will be ignored
      * - A function that receives an {@link Error} and optionally returns a promise.
+     * - A (possibly nested) array of any of the above.
      *
      * @returns
      * - A {@link Subscription} that may be used to pause, resume, or remove the provide listeners if either the listeners were safely added or the token is defused.
      * - `undefined` if no listener could be safely added. This is typically due to the token being cancelled
      *   and indicates any future attempts will also fail.
      */
-    add(...listeners: (CancellableLike | CancellationListener)[]): Subscription | undefined;
+    add(listener: CancellableLike<CancellationListener>, options?: AddCancellableOptions): Subscription | undefined;
     use<X extends CancellableLike>(target: X): X;
     /**
      * Attempts to add a listener to this token.
@@ -65,6 +70,7 @@ export declare abstract class Token {
      */
     get signal(): AbortSignal;
     throwIfCancelled(): void;
+    filter(filter: ErrorFilter): Token;
     static createController(this: void, options?: Token.CreateParams): TokenController;
     static create(this: void, options: Token.CreateParams): Token;
     /** A token that will never be cancelled. */
@@ -91,10 +97,10 @@ export declare namespace Token {
          */
         onDefuse?: ((this: void) => void) | undefined;
         /**
-         * Called on {@link CancellationController.cancel}. If a promise-like is returned, no listeners will be
+         * Called on {@link TokenController#cancel}. If a promise-like is returned, no listeners will be
          * notified of the cancellation until after the promise-like resolves.
          *
-         * If this callback throws or rejects, the {@link CancellationController.cancel} promise will also
+         * If this callback throws or rejects, the {@link TokenController#cancel} promise will also
          * reject after all cancellation listeners and the {@link onBeforeCancel} promise is settled
          * if present.
          */
@@ -102,15 +108,22 @@ export declare namespace Token {
         /**
          * Called after all promises returned by cancellation listeners have either resolved or rejected.
          *
-         * If this callback exists and returns a promise-like, the {@link CancellationController.cancel} promise
+         * If this callback exists and returns a promise-like, the {@link TokenController#cancel} promise
          * will not resolve until after this promise-like is settled.
          *
-         * If this callback throws or rejects, the {@link CancellationController.cancel} promise will
+         * If this callback throws or rejects, the {@link TokenController#cancel} promise will
          * also reject.
          */
         onAfterCancel?: ((this: void, error: Error) => Awaitable<void>) | undefined;
     }
     interface CreateParams extends SubscriptionLifecycle<[ctrl: TokenController], [ctrl: TokenController]>, Callbacks {
+        filter?: ErrorFilter;
+        /**
+         * If `true`, then when all parent tokens are defused, the token will be defused.
+         *
+         * @default false
+         */
+        sealed?: boolean | undefined;
     }
     interface FromAbortSignalParams extends Callbacks {
         /**

package/dist/token/base.js

@@ -1,15 +1,16 @@
-import { CancellationError, toError } from '../error.js';
+import { CancellationTokenBase } from '@youngspe/async-scope-common';
+import { CancellationError, toErrorForCancellation } from '../error.js';
 import * as Symbols from '../symbols.js';
-import { isArray, isIterable } from '../utils.js';
 import { Subscription } from '../events/sub.js';
 import { CancelEvent } from '../token.js';
-export class Token {
+import { isArray, isIterable } from '@youngspe/common-async-utils';
+export class Token extends CancellationTokenBase {
     /** If `true`, this token has been _defused_, meaning it is guaranteed never to be cancelled. */
     get isDefused() {
         return false;
     }
     /**
-     * If `true`, this token has been _cancelled_, and trigger any additional listeners.
+     * If `true`, this token has been _cancelled_, and will not trigger any additional listeners.
      *
      * This is equivalent to `token.error !== undefined`
      *
@@ -21,42 +22,47 @@ export class Token {
     /**
      * Adds listeners
      *
-     * @param listeners - listeners that should be added to this token.
-     * Each parameter may be:
-     * - A {@link CancellableLike}:
-     *   - A {@link Cancellable}
-     *   - A {@link Disposable}
-     *   - An {@link AsyncDisposable}
-     *   - A falsy value, which will be ignored
-     *   - A (possibly nested) array of any of the above.
+     * @param listener - a listener that should be added to this token.
+     * This may be:
+     * - A {@link Cancellable}
+     * - A {@link Disposable}
+     * - An {@link AsyncDisposable}
+     * - A falsy value, which will be ignored
      * - A function that receives an {@link Error} and optionally returns a promise.
+     * - A (possibly nested) array of any of the above.
      *
      * @returns
      * - A {@link Subscription} that may be used to pause, resume, or remove the provide listeners if either the listeners were safely added or the token is defused.
      * - `undefined` if no listener could be safely added. This is typically due to the token being cancelled
      *   and indicates any future attempts will also fail.
      */
-    add(...listeners) {
+    add(listener, options) {
         if (this.isCancelled)
             return undefined;
         if (this.isDefused)
             return Subscription.noop;
         const subs = [];
-        for (let listener of listeners) {
+        const inner = (listener) => {
             if (!listener)
-                continue;
+                return true;
             if (isArray(listener)) {
-                this.add(...listener);
-                continue;
+                for (const child of listener) {
+                    if (!inner(child))
+                        return false;
+                }
+                return true;
             }
             if (typeof listener === 'function') {
                 listener = { cancel: listener };
             }
-            const sub = this.addOne(listener);
+            const sub = this.addOne(listener, options);
             if (!sub)
-                return undefined;
+                return false;
             subs.push(sub);
-        }
+            return true;
+        };
+        if (!inner(listener))
+            return undefined;
         return Subscription.collect(subs);
     }
     use(target) {
@@ -106,6 +112,11 @@ export class Token {
         if (error)
             throw error;
     }
+    filter(filter) {
+        const ctrl = Token.createController({ filter, sealed: true });
+        this.add(ctrl, { passive: true });
+        return ctrl.token;
+    }
     static createController(options) {
         return CancelEvent.createController(options);
     }
@@ -118,7 +129,7 @@ export class Token {
     }
     /** @returns a token that has already been cancelled. */
     static cancelled(reason = new CancellationError()) {
-        return new CancelledToken(toError(reason));
+        return new CancelledToken(toErrorForCancellation(reason));
     }
     /**
      *
@@ -142,8 +153,9 @@ export class Token {
         }
         if (tokens.size > 1) {
             return Token.create({
+                sealed: true,
                 init: ctrl => {
-                    const sub = Subscription.collect(Array.from(tokens, t => t.add(ctrl)));
+                    const sub = Subscription.collect(Array.from(tokens, t => t.add(ctrl, { passive: true })));
                     return {
                         resume: () => {
                             sub.resume();
@@ -162,7 +174,7 @@ export class Token {
     /** @returns a {@link Token} that is cancelled when `signal` is aborted. */
     static fromAbortSignal(signal, options) {
         if (signal.aborted)
-            return new CancelledToken(toError(signal.reason));
+            return new CancelledToken(toErrorForCancellation(signal.reason));
         const { onError, ...callbacks } = options ?? {};
         return Token.create({
             ...callbacks,
@@ -180,6 +192,7 @@ export class Token {
     static from(src) {
         const tokens = new Set();
         const signals = new Set();
+        const visited = new Set();
         const flatten = (src) => {
             if (!src)
                 return undefined;
@@ -205,6 +218,9 @@ export class Token {
                 }
                 return undefined;
             }
+            if (visited.has(src))
+                return undefined;
+            visited.add(src);
             return flatten(src.scope) || flatten(src.token) || flatten(src.signal);
         };
         const cancelled = flatten(src);

package/dist/token.d.ts

@@ -1,4 +1,4 @@
 export { Token, STATIC_TOKEN } from './token/base.ts';
 export { CancelEvent } from './events/cancel.ts';
-export type { TokenController } from './token/base.ts';
+export type { TokenController, AddCancellableOptions, ErrorFilter } from './token/base.ts';
 //# sourceMappingURL=token.d.ts.map

package/dist/types.d.ts

@@ -1,17 +1,6 @@
-/**
- * A value that yields `T` when awaited. Useful for functions that take either the value itself or a
- * promise that yields it.
- *
- * @template T The type of the value returned by `value` when awaited.
- *
- * @example
- * function asyncMultiply(lhs: Awaitable<number>, rhs: Awaitable<number>) {
- *   const [l, r] = await Promise.all([lhs, rhs]);
- *   return l * r;
- * }
- *
- */
-export type Awaitable<T> = T | Promise<T> | PromiseLike<T>;
+import type { OptionalUndefinedProps } from '@youngspe/common-async-utils';
+export type { Awaitable } from '@youngspe/async-scope-common';
+export type { OptionalUndefinedParams, OptionalUndefinedProps } from '@youngspe/common-async-utils';
 /**
  * A value that's treated like `false` in conditional operations like `if` or `&&`
  *
@@ -43,75 +32,21 @@ export type IfExactOptionalPropertiesEnabled<Then, Else> = {
 } extends {
     x?: never;
 } ? Else : Then;
-/** Evalutes to `Then` if `T` is `never`, otherwise `Else`. */
-type IfNever<T, Then, Else> = (T extends any ? Else : never) | (Then & ([T] extends [never] ? unknown : never));
-/**
- * Evaluates to `never` if `T` is `never`, otherwise `U`.
- *
- * @example
- *
- * // This type may or may not contain an error value of type `E`:
- * type State<E> = Ready | Failed<E>;
- * type Ready = { status: 'ready', value: number }
- * // When `E` is `never`, `Failed<E>` is also never thanks to `OrNever<E>`:
- * type Failed<E> = { status: 'failed'; error: E } & OrNever<E>;
- *
- * // This means when `E` is `never`, the type `State<never>` evaluates to
- * // `Ready` to correctly reflect that it can never be in the `Failed` state.
- *
- * // Given a function with this signature:
- * function createState<E>(): State<E> {
- *   return { value: 0 }
- * }
- *
- * // The following operation is valid because we have specified there will
- * // never be an error:
- * const { value } = createState<never>();
- */
-export type OrNever<T, U = unknown> = IfNever<T, never, U>;
-/** Evaluates to `T`, unless `T` is never, in which case it evaluates to `Else`. */
-export type UnlessNeverElse<T, Else> = [T] extends [never] ? Else : T;
-type _OptionalUndefinedParams<A extends any[], R extends any[]> = {
-    [K in keyof R]: undefined;
-} extends R ? A extends [...infer L, ...R] ? [
-    ...L,
-    ...Partial<R>
-] : A : R extends [any, ...infer Rest] ? _OptionalUndefinedParams<A, Rest> : A;
-export type OptionalUndefinedParams<A extends any[]> = _OptionalUndefinedParams<A, A>;
-type SimplifyObject<T> = {
-    [K in keyof T]: T[K];
+export type PartialOrUndefined<T> = IfExactOptionalPropertiesEnabled<{
+    [P in keyof T]?: T[P] | undefined;
+}, Partial<T>>;
+type EraseProps<T> = {
+    [K in keyof T]: any;
 };
-/**
- * Makes properties of `T` that may be `undefined` optional.
- * Useful for a params/options object for a function when a value might not be required depending
- * on the type parameters.
- *
- * @example
- *
- * interface MyParams<T, U> {
- *   items: T[]
- *   // This property may be undefined if a `T` is already a valid `U`, but
- *   // as-is you'll still need to include `transform: undefined` in your options.
- *   transform: ((value: T) => U) | (T extends U ? undefined : never);
- * }
- *
- * function myMap<T, U = T>({
- *   items,
- *   transform,
- * }: OptionalUndefinedProps<MyParams<T, U>>): U[] {
- *   return transform ? items.map(transform) : items as (T & U)[]
- * }
- *
- * const strings = myMap({
- *   items: [1, 2, 3],
- *   transform: String,
- * }); // ['1', '2', '3']
- *
- * // `transform` is not required because `T` and `U` are both `number`.
- * const unchanged = myMap({ items: [1, 2, 3] }); // [1, 2, 3]
- */
-export type OptionalUndefinedProps<T> = SimplifyObject<Partial<T> & {
-    [K in keyof T as undefined extends T[K] ? never : K]: T[K];
-}>;
-export {};
+export type Defined<T = unknown> = NonNullable<T> | (T & null);
+export type UpdateObject<T, U> = T extends Partial<U> ? T & U : U extends never ? never : {
+    [K in keyof (EraseProps<T> & EraseProps<OptionalUndefinedProps<U>>)]: K extends keyof U ? Extract<PropertyKey, K> extends never ? Defined<U[K]> | (undefined extends U[K] ? T[K & keyof T] : never) : T[K & keyof T] | U[K & keyof T] : T[K & keyof T];
+};
+export type SetProps<T, U> = T extends Partial<U> ? T & U : U extends never ? never : U & {
+    [K in keyof T as Exclude<K, keyof (EraseProps<T> | EraseProps<U>)>]: U extends Record<K, any> ? U[K] : U extends Partial<Record<K, infer X>> ? Extract<X, U[K]> | T[K & keyof T] : T[K & keyof T];
+};
+export type BetterOmit<T, K extends PropertyKey> = T extends never ? never : {
+    [_K in keyof T as Exclude<_K, K>]: T[_K];
+};
+export type UndefinedIfDefault<T, Def = object> = T | (Def extends T ? undefined : never);
 //# sourceMappingURL=types.d.ts.map