botframework-webchat-core 4.18.2 → 4.19.0

package/dist/_dtsroll-chunks/B7Whm73Q-tagged.d.ts

@@ -0,0 +1,71 @@
+declare const tag: unique symbol;
+
+// eslint-disable-next-line type-fest/require-exported-types
+type TagContainer<Token> = {
+	readonly [tag]: Token;
+};
+
+type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{[K in Token]: TagMetadata}>;
+
+/**
+Create a [tagged type](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d) that can support [multiple tags](https://github.com/sindresorhus/type-fest/issues/665) and [per-tag metadata](https://medium.com/@ethanresnick/advanced-typescript-tagged-types-improved-with-type-level-metadata-5072fc125fcf).
+
+A type returned by `Tagged` can be passed to `Tagged` again, to create a type with multiple tags.
+
+A tag's name is usually a string (and must be a string, number, or symbol), but each application of a tag can also contain an arbitrary type as its "metadata". See {@link GetTagMetadata} for examples and explanation.
+
+A type `A` returned by `Tagged` is assignable to another type `B` returned by `Tagged` if and only if:
+  - the underlying (untagged) type of `A` is assignable to the underlying type of `B`;
+	- `A` contains at least all the tags `B` has;
+	- and the metadata type for each of `A`'s tags is assignable to the metadata type of `B`'s corresponding tag.
+
+There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
+	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
+	- [Microsoft/TypeScript#4895](https://github.com/microsoft/TypeScript/issues/4895)
+	- [Microsoft/TypeScript#33290](https://github.com/microsoft/TypeScript/pull/33290)
+
+@example
+```
+import type {Tagged} from 'type-fest';
+
+type AccountNumber = Tagged<number, 'AccountNumber'>;
+type AccountBalance = Tagged<number, 'AccountBalance'>;
+
+function createAccountNumber(): AccountNumber {
+	// As you can see, casting from a `number` (the underlying type being tagged) is allowed.
+	return 2 as AccountNumber;
+}
+
+declare function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance;
+
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type!
+// Critically, you could not accidentally use an `AccountBalance` as an `AccountNumber`.
+// @ts-expect-error
+getMoneyForAccount(2);
+
+// You can also use tagged values like their underlying, untagged type.
+// I.e., this will compile successfully because an `AccountNumber` can be used as a regular `number`.
+// In this sense, the underlying base type is not hidden, which differentiates tagged types from opaque types in other languages.
+const accountNumber = createAccountNumber() + 2;
+```
+
+@example
+```
+import type {Tagged} from 'type-fest';
+
+// You can apply multiple tags to a type by using `Tagged` repeatedly.
+type Url = Tagged<string, 'URL'>;
+type SpecialCacheKey = Tagged<Url, 'SpecialCacheKey'>;
+
+// You can also pass a union of tag names, so this is equivalent to the above, although it doesn't give you the ability to assign distinct metadata to each tag.
+type SpecialCacheKey2 = Tagged<string, 'URL' | 'SpecialCacheKey'>;
+```
+
+@category Type
+*/
+type Tagged<Type, TagName extends PropertyKey, TagMetadata = never> = Type & Tag<TagName, TagMetadata>;
+
+export type { Tagged as T };

package/dist/_dtsroll-chunks/C-MxR98A-botframework-webchat-core-debug-api.d.ts

@@ -0,0 +1,135 @@
+/**
+Represents an array with `unknown` value.
+
+Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
+
+@example
+```
+import type {UnknownArray} from 'type-fest';
+
+type IsArray<T> = T extends UnknownArray ? true : false;
+
+type A = IsArray<['foo']>;
+//=> true
+
+type B = IsArray<readonly number[]>;
+//=> true
+
+type C = IsArray<string>;
+//=> false
+```
+
+@category Type
+@category Array
+*/
+type UnknownArray = readonly unknown[];
+
+/**
+Extracts the element type of an array or tuple.
+
+Use-cases:
+- When you need type-safe element extraction that returns `never` for non-arrays.
+- When extracting element types from generic array parameters in function signatures.
+- For better readability and explicit intent over using `T[number]` directly.
+
+Note: Returns `never` if the type is not an array.
+
+@example
+```
+import type {ArrayElement} from 'type-fest';
+
+// Arrays
+type StringArray = ArrayElement<string[]>;
+//=> string
+
+// Tuples
+type Tuple = ArrayElement<[1, 2, 3]>;
+//=> 1 | 2 | 3
+
+// Type-safe
+type NotArray = ArrayElement<{a: string}>;
+//=> never
+
+// Practical example
+declare function getRandomElement<T extends readonly unknown[]>(array: T): ArrayElement<T>;
+
+getRandomElement(['foo', 'bar', 'baz'] as const);
+//=> 'foo' | 'bar' | 'baz'
+```
+
+@see {@link ArrayValues} - For directly extracting values from a constant array type.
+@see {@link IterableElement} - For iterables like `Set`, `Map`, and generators (not suitable for all use cases due to different inference behavior).
+
+@category Array
+*/
+type ArrayElement<T> =
+	T extends UnknownArray
+		? T[number]
+		: never;
+
+type BaseContext = {
+    readonly [key: string]: unknown;
+};
+type BreakpointObject<TName extends string, TContext extends object> = Readonly<Record<TName, (__DEBUG_CONTEXT__: TContext, ...args: any[]) => void>>;
+interface DebugAPIType<TBreakpointName extends string, TContext extends object> {
+    /**
+     * 🚨 This is strictly for debugging only.
+     *
+     * List of execution points for debugger to break into.
+     *
+     * Type `debug($0.webChat.breakpoint.functionName)` in DevTools to break into specific execution.
+     */
+    get breakpoint(): BreakpointObject<TBreakpointName, TContext>;
+    /**
+     * 🚨 This is strictly for debugging only.
+     *
+     * Break into debugger immediately.
+     *
+     * Note: if Content Security Policy is enabled, it may not break into debugger.
+     */
+    get debugger(): void;
+}
+/**
+ * This is the triggering side of the debugging API.
+ *
+ * This object should be kept inside the code that need to be debugged.
+ *
+ * For public consumption, call `toPublic()` to create an object for receiving side.
+ */
+interface RestrictedDebugAPIType<TBreakpointName extends string, TContext extends BaseContext> {
+    /**
+     * Creates a public version of Debug API for external consumption.
+     */
+    toPublic(): DebugAPIType<TBreakpointName, TContext>;
+    /**
+     * Triggers a breakpoint function.
+     */
+    get UNSAFE_callBreakpoint(): Readonly<Record<TBreakpointName, (...args: any[]) => void>>;
+    readonly '~types': {
+        readonly public: DebugAPIType<TBreakpointName, TContext>;
+    };
+}
+type InferPublic<T extends RestrictedDebugAPIType<any, any>> = T['~types']['public'];
+
+declare class DebugAPI<TBreakpointName extends string, TContext extends object> implements DebugAPIType<TBreakpointName, TContext> {
+    #private;
+    constructor(breakpoint: BreakpointObject<TBreakpointName, TContext>, context: TContext);
+    get breakpoint(): Readonly<Record<TBreakpointName, (__DEBUG_CONTEXT__: TContext, ...args: any[]) => void>>;
+    get debugger(): undefined;
+}
+
+type AsGetters<T> = {
+    readonly [K in keyof T]: () => T[K];
+};
+declare abstract class RestrictedDebugAPI<TBreakpointName extends string, TContext extends BaseContext> implements RestrictedDebugAPIType<TBreakpointName, TContext> {
+    #private;
+    constructor(breakpointNames: readonly TBreakpointName[], contextGetters: AsGetters<TContext>);
+    toPublic(): DebugAPI<TBreakpointName, TContext>;
+    UNSAFE_callBreakpoint: Readonly<Record<TBreakpointName, (...args: any[]) => void>>;
+    get '~types'(): Readonly<{
+        public: any;
+    }>;
+}
+
+export { RestrictedDebugAPI as R };
+export type { ArrayElement as A, InferPublic as I };

package/dist/_dtsroll-chunks/CAquHfZK-botframework-webchat-base.utils.d.ts

@@ -0,0 +1,17 @@
+declare function isForbiddenPropertyName(propertyName: string): boolean;
+
+/** @deprecated Will be removed on or after 2028-03-18. */
+type OneOrMany<T> = T | readonly T[];
+
+/** @deprecated Will be removed on or after 2028-03-16. */
+declare function singleToArray<T>(singleOrArray: T | readonly T[]): readonly T[];
+
+type PromiseWithResolvers<T> = {
+    promise: Promise<T>;
+    reject: (error: unknown) => void;
+    resolve: (value: T) => void;
+};
+declare function withResolvers<T>(): PromiseWithResolvers<T>;
+
+export { isForbiddenPropertyName as i, singleToArray as s, withResolvers as w };
+export type { OneOrMany as O, PromiseWithResolvers as P };