@mappedin/blue-dot 6.9.1-beta.0 → 6.10.0-beta.0

package/lib/esm/index.d.ts

@@ -1,6 +1,6 @@
 import { Coordinate, Floor, MapView, Model } from "@mappedin/mappedin-js";
 
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/primitive.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/primitive.d.ts
 
 /**
 Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
@@ -9,27 +9,81 @@ Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/
 */
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/observable-like.d.ts
-declare global {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
-  interface SymbolConstructor {
-    readonly observable: symbol;
-  }
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/is-any.d.ts
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
+	return obj[key];
 }
 
-/**
-@remarks
-The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
-As well, some guidance on making an `Observable` to not include `closed` property.
-@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
-@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
-@see https://github.com/benlesh/symbol-observable#making-an-object-observable
-
-@category Observable
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
 */
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/is-optional-key-of.d.ts
+/**
+Returns a boolean for whether the given key is an optional key of type.
+
+This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
+
+@example
+```
+import type {IsOptionalKeyOf} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+interface Admin {
+	name: string;
+	surname?: string;
+}
+
+type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
+//=> true
 
+type T2 = IsOptionalKeyOf<User, 'name'>;
+//=> false
+
+type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
+//=> boolean
+
+type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
+//=> false
+
+type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsOptionalKeyOf<Type extends object, Key$1 extends keyof Type> = IsAny<Type | Key$1> extends true ? never : Key$1 extends keyof Type ? Type extends Record<Key$1, Type[Key$1]> ? false : true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/optional-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/optional-keys-of.d.ts
 /**
 Extract all optional keys from the given type.
 
@@ -63,11 +117,11 @@ const update2: UpdateOperation<User> = {
 
 @category Utilities
 */
-type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
-? (keyof { [Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never }) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
+type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
 : never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/required-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/required-keys-of.d.ts
 /**
 Extract all required keys from the given type.
 
@@ -92,10 +146,10 @@ const validator2 = createValidation<User>('surname', value => value.length < 25)
 
 @category Utilities
 */
-type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
-? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never;
+type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/is-never.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/is-never.d.ts
 /**
 Returns a boolean for whether the given type is `never`.
 
@@ -139,64 +193,120 @@ endIfEqual('abc', '123');
 */
 type IsNever<T> = [T] extends [never] ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/if-never.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/if.d.ts
 /**
-An if-else-like type that resolves depending on whether the given type is `never`.
+An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
+
+Use-cases:
+- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.
 
-@see {@link IsNever}
+Note:
+- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
+- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.
 
 @example
 ```
-import type {IfNever} from 'type-fest';
+import {If} from 'type-fest';
 
-type ShouldBeTrue = IfNever<never>;
-//=> true
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
 
-type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
-//=> 'bar'
-```
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
 
-@category Type Guard
-@category Utilities
-*/
-type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/is-any.d.ts
-// Can eventually be replaced with the built-in once this library supports
-// TS5.4+ only. Tracked in https://github.com/sindresorhus/type-fest/issues/848
-type NoInfer<T> = T extends infer U ? U : never;
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
 
-/**
-Returns a boolean for whether the given type is `any`.
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
 
-@link https://stackoverflow.com/a/49928360/1490091
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
+```
 
-Useful in type utilities, such as disallowing `any`s to be passed to a function.
+@example
+```
+import {If, IsAny, IsNever} from 'type-fest';
+
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
+
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
 
 @example
 ```
-import type {IsAny} from 'type-fest';
+import {If, IsEqual} from 'type-fest';
 
-const typedObject = {a: 1, b: 2} as const;
-const anyObject: any = {a: 1, b: 2};
+type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
 
-function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
-	return obj[key];
-}
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
 
-const typedA = get(typedObject, 'a');
-//=> 1
+type B = IfEqual<string, number, 'equal', 'not equal'>;
+//=> 'not equal'
+```
 
-const anyA = get(anyObject, 'a');
-//=> any
+Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
+
+@example
+```
+import type {If, IsEqual, StringRepeat} from 'type-fest';
+
+type HundredZeroes = StringRepeat<'0', 100>;
+
+// The following implementation is not tail recursive
+type Includes<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? If<IsEqual<First, Char>,
+			'found',
+			Includes<Rest, Char>>
+		: 'not found';
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type Fails = Includes<HundredZeroes, '1'>;
+//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
+type IncludesWithoutIf<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? IsEqual<First, Char> extends true
+			? 'found'
+			: IncludesWithoutIf<Rest, Char>
+		: 'not found';
+
+// Now, instantiations with long strings will work
+type Works = IncludesWithoutIf<HundredZeroes, '1'>;
+//=> 'not found'
 ```
 
 @category Type Guard
 @category Utilities
 */
-type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/internal/type.d.ts
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+type BuiltIns = Primitive | void | Date | RegExp;
+/**
+Test if the given function has multiple call signatures.
+
+Needed to handle the case of a single call signature with properties.
+
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
+*/
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
+  (...arguments_: infer A): unknown;
+  (...arguments_: infer B): unknown;
+} ? B extends A ? A extends B ? false : true : true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/simplify.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/simplify.d.ts
 /**
 Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 
@@ -251,12 +361,12 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 ```
 
 @link https://github.com/microsoft/TypeScript/issues/15300
-@see SimplifyDeep
+@see {@link SimplifyDeep}
 @category Object
 */
 type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/omit-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/omit-index-signature.d.ts
 /**
 Omit any index signatures from the given object type, leaving only explicitly defined properties.
 
@@ -344,12 +454,12 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 // => { foo: 'bar'; qux?: 'baz' | undefined; }
 ```
 
-@see PickIndexSignature
+@see {@link PickIndexSignature}
 @category Object
 */
 type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/pick-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/pick-index-signature.d.ts
 /**
 Pick only index signatures from the given object type, leaving out all explicitly defined properties.
 
@@ -392,12 +502,12 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 // }
 ```
 
-@see OmitIndexSignature
+@see {@link OmitIndexSignature}
 @category Object
 */
 type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/merge.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/merge.d.ts
 // Merges two objects without worrying about index signatures.
 type SimpleMerge<Destination, Source> = { [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source;
 
@@ -437,47 +547,7 @@ export type FooBar = Merge<Foo, Bar>;
 */
 type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/if-any.d.ts
-/**
-An if-else-like type that resolves depending on whether the given type is `any`.
-
-@see {@link IsAny}
-
-@example
-```
-import type {IfAny} from 'type-fest';
-
-type ShouldBeTrue = IfAny<any>;
-//=> true
-
-type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/internal/type.d.ts
-/**
-Matches any primitive, `void`, `Date`, or `RegExp` value.
-*/
-type BuiltIns = Primitive | void | Date | RegExp;
-/**
-Test if the given function has multiple call signatures.
-
-Needed to handle the case of a single call signature with properties.
-
-Multiple call signatures cannot currently be supported due to a TypeScript limitation.
-@see https://github.com/microsoft/TypeScript/issues/29732
-*/
-type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
-  (...arguments_: infer A): unknown;
-  (...arguments_: infer B): unknown;
-} ? B extends A ? A extends B ? false : true : true : false;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/internal/object.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/internal/object.d.ts
 
 /**
 Merges user specified options with default options.
@@ -531,10 +601,9 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 // Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
 ```
 */
-type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = IfAny<SpecifiedOptions, Defaults, IfNever<SpecifiedOptions, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? Extract<SpecifiedOptions[Key], undefined> extends never ? Key : never : Key]: SpecifiedOptions[Key] }> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
->>;
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/partial-deep.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/partial-deep.d.ts
 /**
 @see {@link PartialDeep}
 */
@@ -549,24 +618,23 @@ type PartialDeepOptions = {
   Allows `undefined` values in non-tuple arrays.
   	- When set to `true`, elements of non-tuple arrays can be `undefined`.
   - When set to `false`, only explicitly defined elements are allowed in non-tuple arrays, ensuring stricter type checking.
-  	@default true
+  	@default false
   	@example
-  You can prevent `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}` as the second type argument:
+  You can allow `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}` as the second type argument:
   	```
   import type {PartialDeep} from 'type-fest';
   	type Settings = {
   	languages: string[];
   };
-  	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}>;
-  	partialSettings.languages = [undefined]; // Error
-  partialSettings.languages = []; // Ok
+  	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}>;
+  	partialSettings.languages = [undefined]; // OK
   ```
   */
   readonly allowUndefinedInNonTupleArrays?: boolean;
 };
 type DefaultPartialDeepOptions = {
   recurseIntoArrays: false;
-  allowUndefinedInNonTupleArrays: true;
+  allowUndefinedInNonTupleArrays: false;
 };
 
 /**
@@ -580,19 +648,19 @@ Use-cases:
 ```
 import type {PartialDeep} from 'type-fest';
 
-const settings: Settings = {
+let settings = {
 	textEditor: {
 		fontSize: 14,
 		fontColor: '#000000',
-		fontWeight: 400
+		fontWeight: 400,
 	},
 	autocomplete: false,
-	autosave: true
+	autosave: true,
 };
 
-const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
-	return {...settings, ...savedSettings};
-}
+const applySavedSettings = (savedSettings: PartialDeep<typeof settings>) => (
+	{...settings, ...savedSettings, textEditor: {...settings.textEditor, ...savedSettings.textEditor}}
+);
 
 settings = applySavedSettings({textEditor: {fontWeight: 500}});
 ```
@@ -602,13 +670,15 @@ By default, this does not affect elements in array and tuple types. You can chan
 ```
 import type {PartialDeep} from 'type-fest';
 
-type Settings = {
-	languages: string[];
-}
+type Shape = {
+	dimensions: [number, number];
+};
 
-const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
-	languages: [undefined]
+const partialShape: PartialDeep<Shape, {recurseIntoArrays: true}> = {
+	dimensions: [], // OK
 };
+
+partialShape.dimensions = [15]; // OK
 ```
 
 @see {@link PartialDeepOptions}
@@ -619,8 +689,8 @@ const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
 @category Map
 */
 type PartialDeep<T, Options extends PartialDeepOptions = {}> = _PartialDeep<T, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
-type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown)) ? T : IsNever<keyof T> extends true // For functions with no properties
-? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T extends object ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown)) ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T extends ((...arguments_: any[]) => unknown) ? IsNever<keyof T> extends true ? T // For functions with no properties
+: HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & PartialObjectDeep<T, Options> : T extends object ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
 ? Options['recurseIntoArrays'] extends true ? ItemType[] extends T // Test for arrays (non-tuples) specifically
 ? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
 ? ReadonlyArray<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : Array<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep<T, Options> // Tuples behave properly
@@ -650,9 +720,9 @@ type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {
 /**
 Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
 */
-type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = (ObjectType extends ((...arguments_: any) => unknown) ? (...arguments_: Parameters<ObjectType>) => ReturnType<ObjectType> : {}) & ({ [KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options> });
+type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = { [KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options> };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/readonly-deep.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/readonly-deep.d.ts
 /**
 Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.
 
@@ -676,7 +746,7 @@ const data: ReadonlyDeep<typeof dataJson> = dataJson;
 export default data;
 
 // test.ts
-import data from './main';
+import data from './main.d.ts';
 
 data.foo.push('bar');
 //=> error TS2339: Property 'push' does not exist on type 'readonly string[]'
@@ -690,9 +760,9 @@ Note that types containing overloaded functions are not made deeply readonly due
 @category Map
 */
 type ReadonlyDeep<T> = T extends BuiltIns ? T : T extends (new (...arguments_: any[]) => unknown) ? T // Skip class constructors
-: T extends ((...arguments_: any[]) => unknown) ? {} extends ReadonlyObjectDeep<T> ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T> : T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>> ? ReadonlyMapDeep<KeyType, ValueType> : T extends Readonly<ReadonlySet<infer ItemType>> ? ReadonlySetDeep<ItemType> :
+: T extends ((...arguments_: any[]) => unknown) ? {} extends _ReadonlyObjectDeep<T> ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & _ReadonlyObjectDeep<T> : T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>> ? ReadonlyMapDeep<KeyType, ValueType> : T extends Readonly<ReadonlySet<infer ItemType>> ? ReadonlySetDeep<ItemType> :
 // Identify tuples to avoid converting them to arrays inadvertently; special case `readonly [...never[]]`, as it emerges undesirably from recursive invocations of ReadonlyDeep below.
-T extends readonly [] | readonly [...never[]] ? readonly [] : T extends readonly [infer U, ...infer V] ? readonly [ReadonlyDeep<U>, ...ReadonlyDeep<V>] : T extends readonly [...infer U, infer V] ? readonly [...ReadonlyDeep<U>, ReadonlyDeep<V>] : T extends ReadonlyArray<infer ItemType> ? ReadonlyArray<ReadonlyDeep<ItemType>> : T extends object ? ReadonlyObjectDeep<T> : unknown;
+T extends readonly [] | readonly [...never[]] ? readonly [] : T extends readonly [infer U, ...infer V] ? readonly [ReadonlyDeep<U>, ...ReadonlyDeep<V>] : T extends readonly [...infer U, infer V] ? readonly [...ReadonlyDeep<U>, ReadonlyDeep<V>] : T extends ReadonlyArray<infer ItemType> ? ReadonlyArray<ReadonlyDeep<ItemType>> : T extends object ? _ReadonlyObjectDeep<T> : unknown;
 /**
 Same as `ReadonlyDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `ReadonlyDeep`.
 */
@@ -706,7 +776,7 @@ type ReadonlySetDeep<ItemType$1> = {} & Readonly<ReadonlySet<ReadonlyDeep<ItemTy
 /**
 Same as `ReadonlyDeep`, but accepts only `object`s as inputs. Internal helper for `ReadonlyDeep`.
 */
-type ReadonlyObjectDeep<ObjectType extends object> = { readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]> };
+type _ReadonlyObjectDeep<ObjectType extends object> = { readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]> };
 //#endregion
 //#region ../packages/common/extensions.d.ts
 interface MapViewExtension<T> {
@@ -901,6 +971,11 @@ type BlueDotState = {
    * @default true
    */
   preventOutOfBounds: boolean;
+  /**
+   * If true, timestamp will be used to discard updates which are received out of order.
+   * @default true
+   */
+  discardStaleUpdates: boolean;
 };
 type BlueDotUpdateState = PartialDeep<BlueDotState>;
 /**
@@ -961,7 +1036,7 @@ type BlueDotUpdateOptions = {
 };
 type GeolocationPositionExtended = GeolocationPosition & {
   coords: GeolocationPosition['coords'] & {
-    readonly floorLevel?: number;
+    readonly floorLevel?: number | null;
   };
 };
 //#endregion
@@ -1132,18 +1207,26 @@ declare class BlueDot implements MapViewExtension<BlueDotState> {
    */
   watchDeviceOrientation: (watch: boolean) => Promise<void>;
   /**
-   * Manually override some position properties of the Blue Dot.
-   * Accepts a full GeolocationPosition object or a partial {@link BlueDotPositionUpdate} object.
+   * Set the Blue Dot position to specific coordinates or override some properties of the device geolocation.
    *
-   * @remarks This will emit a 'position-update' event.
+   * @remarks If `floorLevel` is provided with {@link GeolocationPositionExtended}, the floor will be resolved asynchronously and the position will not be applied until this is completed.
    *
-   * @example Manually set the accuracy and heading
+   * @param position - The position to set. Use {@link BlueDotPositionUpdate} for manual positioning,
+   *   a GeolocationPosition object, or undefined to clear the manual position.
+   * @param options - Optional update options (silent, animate).
+   *
+   * @example Set position with floor
    * ```ts
-   * api.BlueDot.update({ accuracy: 10, heading: 90 });
+   * blueDot.update({
+   *   latitude: 43.123,
+   *   longitude: -79.456,
+   *   accuracy: 5,
+   *   floorOrFloorId: floor
+   * });
    * ```
-   * @example Reset accuracy and heading to device values
+   * @example Clear manual position properties and return to device geolocation
    * ```ts
-   * api.BlueDot.update({ accuracy: 'device', heading: 'device' });
+   * blueDot.update(undefined);
    * ```
    */
   update: (position: GeolocationPositionExtended | BlueDotPositionUpdate | undefined, options?: BlueDotUpdateOptions) => void;

package/lib/esm/index.js

@@ -1 +1 @@
-import{b as o,c as t}from"./chunk-X6CIQEJY.js";o();export{t as BlueDot};
+import{b as o,c as t}from"./chunk-77XV5TVI.js";o();export{t as BlueDot};