@league-of-foundry-developers/foundry-vtt-types 9.280.1 → 12.331.1-beta

package/src/types/config.d.ts

@@ -1,183 +0,0 @@
-declare global {
-  /**
-   * Some global variables (such as {@link game}) are only initialized after certain events have happened during the
-   * initialization of Foundry VTT. For that reason, the correct types for these variables include the types for the
-   * uninitialized state.
-   *
-   * While this is correct from a type checking perspective, it can be inconvenient to have to type guard these global
-   * variables everywhere. Some users might prefer the convenience over the 100% correctness in type checking.
-   *
-   * For this reason, this interface provides a way for users to configure certain global variables to be typed more
-   * leniently, i.e., as the types of their initialized state. This is done via declaration merging. To configure a
-   * specific global variable to be typed leniently, the user simply needs to merge a property with the name of the
-   * variable into this interface (the type doesn't matter).
-   *
-   * The currently supported variables are:
-   * - {@link game}
-   * - {@link socket}
-   * - {@link ui}
-   * - {@link canvas}
-   *
-   * @example
-   * ```typescript
-   * declare global {
-   *   interface LenientGlobalVariableTypes {
-   *     game: never; // the type doesn't matter
-   *   }
-   * }
-   *
-   * const referenceToGame: Game = game; // ok! :)
-   * ```
-   */
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface
-  interface LenientGlobalVariableTypes {}
-
-  /**
-   * This interface is used to configure the used document classes at a type
-   * level. Module and system authors should use declaration merging to provide
-   * the types of their configured document classes. It is extremely important
-   * that this is kept in sync with the configuration that actually happens at
-   * runtime.
-   *
-   * @example
-   * ```typescript
-   * // myActor.ts
-   * class MyActor extends Actor {}
-   *
-   * // entryPoint.ts
-   * import { MyActor } from './myActor'
-   *
-   * hooks.once('init', () => {
-   *   CONFIG.Actor.documentClass = typeof MyActor;
-   * });
-   *
-   * declare global {
-   *   interface DocumentClassConfig {
-   *     Actor: typeof MyActor
-   *   }
-   * }
-   * ```
-   */
-  //eslint-disable-next-line @typescript-eslint/no-empty-interface
-  interface DocumentClassConfig {}
-
-  /**
-   * This interface is used to configure the used object classes at a type
-   * level. Module and system authors should use declaration merging to provide
-   * the types of their configured object classes. It is extremely important
-   * that this is kept in sync with the configuration that actually happens at
-   * runtime.
-   *
-   * @example
-   * ```typescript
-   * // myToken.ts
-   * class MyToken extends Token {}
-   *
-   * // entryPoint.ts
-   * import { MyToken } from './myToken'
-   *
-   * Hooks.once('init', () => {
-   *   CONFIG.Token.objectClass = MyToken;
-   * });
-   *
-   * declare global {
-   *   interface PlaceableObjectClassConfig {
-   *     Token: typeof MyToken;
-   *   }
-   * }
-   * ```
-   */
-  //eslint-disable-next-line @typescript-eslint/no-empty-interface
-  interface PlaceableObjectClassConfig {}
-
-  /**
-   * This interface together with {@link SourceConfig} is used to configure the
-   * types of the `data`  and `data._source` properties of the
-   * {@link foundry.documents.BaseActor} and {@link foundry.documents.BaseItem}
-   * classes. System authors should use declaration merging to provide the types
-   * that match their `template.json` file. It is also very important for these
-   * types to stay in sync with the `template.json` file, otherwise unexpected
-   * runtime errors might appear.
-   *
-   * @example
-   * ```typescript
-   * interface ArmorDataSourceData {
-   *   armorValue: number;
-   * }
-   *
-   * interface ArmorDataSource {
-   *   type: 'armor';
-   *   data: ArmorDataSourceData;
-   * }
-   *
-   * interface WeaponDataSourceData {
-   *   damagePerHit: number;
-   *   attackSpeed: number;
-   * }
-   *
-   * interface WeaponDataSource {
-   *   type: 'weapon';
-   *   data: WeaponDataSourceData;
-   * }
-   *
-   * interface ArmorDataPropertiesData extends ArmorDataSourceData {
-   *   weight: number;
-   * }
-   *
-   * interface ArmorDataProperties {
-   *   type: 'armor';
-   *   data: ArmorDataPropertiesData;
-   * }
-   *
-   * interface WeaponDataPropertiesData extends WeaponDataSourceData {
-   *   damage: number;
-   * }
-   *
-   * interface WeaponDataProperties {
-   *   type: 'weapon';
-   *   data: WeaponDataPropertiesData;
-   * }
-   *
-   * type MyItemDataSource = ArmorDataSource | WeaponDataSource;
-   * type MyItemDataProperties = ArmorDataProperties | WeaponDataProperties;
-   *
-   * declare global {
-   *   interface DataConfig {
-   *     Item: MyItemDataProperties;
-   *   }
-   *
-   *   interface SourceConfig {
-   *     Item: MyItemDataSource;
-   *   }
-   * }
-   * const item = await Item.create({
-   *   name: 'Axe',
-   *   type: 'weapon',
-   *   attackSpeed: 1,
-   *   damage: 5
-   * });
-   *
-   * if(item.data.type === 'weapon') {
-   *   const damage: number = item.data.data.damage;
-   * }
-   *
-   * if(item.data._source.type === 'armor') {
-   *   const armorValue = item.data._source.data.armorValue;
-   * }
-   * ```
-   */
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface
-  interface DataConfig {}
-
-  /** @see {@link DataConfig} */
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface
-  interface SourceConfig {}
-
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface
-  interface FlagConfig {}
-
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface
-  interface WebRTCConfig {}
-}
-
-export {};

package/src/types/helperTypes.d.ts

@@ -1,151 +0,0 @@
-import DocumentData, { AnyDocumentData } from '../foundry/common/abstract/data.mjs';
-import Document from '../foundry/common/abstract/document.mjs';
-import EmbeddedCollection from '../foundry/common/abstract/embedded-collection.mjs';
-
-export type PropertiesDataType<T extends Document<any, any> | AnyDocumentData> = T extends DocumentData<
-  any,
-  infer U,
-  any,
-  any
->
-  ? U
-  : T extends Document<infer U, any>
-  ? PropertiesDataType<U>
-  : never;
-
-type PropertyTypeToSourceType<T> = T extends EmbeddedCollection<infer U, any>
-  ? SourceDataType<InstanceType<U>>[]
-  : T extends Array<infer U>
-  ? Array<PropertyTypeToSourceType<U>>
-  : T extends AnyDocumentData
-  ? SourceDataType<T>
-  : T;
-
-export type PropertiesToSource<T extends object> = {
-  [Key in keyof T]: PropertyTypeToSourceType<T[Key]>;
-};
-
-type SourceDataType<T extends Document<any, any> | AnyDocumentData> = T extends DocumentData<
-  any,
-  any,
-  infer U,
-  any,
-  any
->
-  ? U
-  : T extends Document<infer U, any>
-  ? SourceDataType<U>
-  : never;
-
-/**
- * Returns the type of the constructor data for the given {@link DocumentData}.
- */
-export type ConstructorDataType<T extends AnyDocumentData> = T['_initializeSource'] extends (data: infer U) => any
-  ? U
-  : never;
-
-type ObjectToDeepPartial<T> = T extends object ? DeepPartial<T> : T;
-
-export type PropertyTypeToSourceParameterType<T> = ObjectToDeepPartial<PropertyTypeToSourceType<T>>;
-
-// TODO: Find a way to avoid this helper
-export type FieldReturnType<T extends DocumentField<any>, U extends Partial<DocumentField<any>>> = Omit<T, keyof U> &
-  Exclude<U, 'undefined'>;
-
-export type DocumentConstructor = Pick<typeof Document, keyof typeof Document> &
-  (new (...args: any[]) => Document<any, any>);
-
-export type PlaceableObjectConstructor = Pick<typeof PlaceableObject, keyof typeof PlaceableObject> &
-  (new (...args: any[]) => PlaceableObject<any>);
-
-export type ConfiguredDocumentClass<T extends DocumentConstructor> = ConfiguredDocumentClassForName<
-  T['metadata']['name']
->;
-
-export type DocumentType =
-  | 'Actor'
-  | 'Adventure'
-  | 'Cards'
-  | 'ChatMessage'
-  | 'Combat'
-  | 'FogExploration'
-  | 'Folder'
-  | 'Item'
-  | 'JournalEntry'
-  | 'Macro'
-  | 'Playlist'
-  | 'RollTable'
-  | 'Scene'
-  | 'Setting'
-  | 'User'
-  | 'ActiveEffect'
-  | 'Card'
-  | 'TableResult'
-  | 'PlaylistSound'
-  | 'AmbientLight'
-  | 'AmbientSound'
-  | 'Combatant'
-  | 'Drawing'
-  | 'MeasuredTemplate'
-  | 'Note'
-  | 'Tile'
-  | 'Token'
-  | 'Wall';
-
-export type PlaceableDocumentType =
-  | 'AmbientLight'
-  | 'AmbientSound'
-  | 'Drawing'
-  | 'MeasuredTemplate'
-  | 'Note'
-  | 'Tile'
-  | 'Token'
-  | 'Wall';
-
-export type DocumentSubTypes<T extends DocumentType> = 'type' extends keyof InstanceType<
-  ConfiguredDocumentClassForName<T>
->['data']
-  ? InstanceType<ConfiguredDocumentClassForName<T>>['data']['type']
-  : typeof foundry.CONST.BASE_DOCUMENT_TYPE;
-
-export type ConfiguredDocumentClassForName<Name extends DocumentType> = CONFIG[Name]['documentClass'];
-
-export type ConfiguredObjectClassForName<Name extends PlaceableDocumentType> = CONFIG[Name]['objectClass'];
-
-export type ConfiguredData<Name extends string> = Name extends keyof DataConfig ? DataConfig[Name] : {};
-
-export type ConfiguredSource<Name extends string> = Name extends keyof SourceConfig ? SourceConfig[Name] : {};
-
-export type ConfiguredFlags<T extends string> = T extends keyof FlagConfig
-  ? FlagConfig[T] & Record<string, unknown>
-  : Record<string, unknown>;
-
-export type ToObjectFalseType<T> = T extends {
-  toObject: (source: false) => infer U;
-}
-  ? U
-  : T;
-
-export type ConfiguredSheetClass<T extends DocumentConstructor> = T['metadata']['name'] extends keyof CONFIG
-  ? 'sheetClass' extends keyof CONFIG[T['metadata']['name']]
-    ? CONFIG[T['metadata']['name']]['sheetClass']
-    : never
-  : T;
-
-export type ObjectClass<T extends DocumentConstructor> = T['metadata']['name'] extends keyof CONFIG
-  ? 'objectClass' extends keyof CONFIG[T['metadata']['name']]
-    ? CONFIG[T['metadata']['name']]['objectClass']
-    : never
-  : T;
-
-export type LayerClass<T extends DocumentConstructor> = T['metadata']['name'] extends keyof CONFIG
-  ? 'layerClass' extends keyof CONFIG[T['metadata']['name']]
-    ? CONFIG[T['metadata']['name']]['layerClass']
-    : never
-  : T;
-
-export type DataSourceForPlaceable<P extends PlaceableObject> = P extends PlaceableObject<infer Doc>
-  ? Doc extends Document<infer D, any>
-    ? D['_source']
-    : never
-  : never;

package/src/types/index.d.ts

@@ -1,3 +0,0 @@
-import './augments';
-import './config';
-import './utils';

package/src/types/utils.d.ts

@@ -1,143 +0,0 @@
-/**
- * Recursively sets keys of an object to optional. Used primarily for update methods
- * @internal
- */
-type DeepPartial<T> = {
-  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
-};
-
-/**
- * Make all properties in T optional and explicitly allow `undefined`
- * @internal
- */
-type InexactPartial<T> = {
-  [P in keyof T]?: T[P] | undefined;
-};
-
-/**
- * References the constructor of type `T`
- * @internal
- */
-type ConstructorOf<T> = new (...args: any) => T;
-
-/**
- * Omit properties of `T` which are of type `U`.
- *
- * @typeParam T - Object type from which properties will be omitted.
- * @typeParam U - Properties of this type will be omitted.
- * @internal
- */
-type OmitOfType<T extends object, U> = { [k in keyof T as T[k] extends U ? never : k]: T[k] };
-
-/**
- * If T extends `U`, the resulting type is `R`, otherwise it is `T`.
- *
- * @typeParam T - Original type.
- * @typeParam U - Only convert types of this type.
- * @typeParam R - Adjust to this type.
- * @internal
- */
-type TypeToType<T, U, R> = T extends U ? R : T;
-
-/**
- * Map the types of properties of `T` to `R` if they are of type `U`.
- *
- * @typeParam T - Object type that will have its properties' types adjusted.
- * @typeParam U - Adjust the types of properties of this type.
- * @typeParam R - Type that properties' types will be adjusted to.
- * @internal
- */
-type MapTypeToType<T, U, R> = { [k in keyof T]: TypeToType<T[k], U, R> };
-
-/**
- * Omit properties of `T` which are assignable from `U`.
- *
- * @typeParam T - Object type that will have its properties omitted.
- * @typeParam U - Properties with types that are assignable from this type will be omitted.
- * @internal
- */
-type OmitAssignableFromType<T extends object, U> = { [k in keyof T as U extends T[k] ? never : k]: T[k] };
-
-/**
- * Omit properties of `T` which are not assignable from `U`.
- *
- * @typeParam T - Object type that will have its properties omitted.
- * @typeParam U - Properties with types that are not assignable from this type will be omitted.
- * @internal
- */
-type OmitNotAssignableFromType<T extends object, U> = { [k in keyof T as U extends T[k] ? k : never]: T[k] };
-
-/**
- * Expand an object that contains keys in dotted notation
- * @internal
- */
-type Expanded<O> = O extends Record<string, unknown>
-  ? {
-      [KO in keyof O as KO extends `${infer A}.${string}` ? A : KO]: KO extends `${string}.${infer B}`
-        ? Expanded<{ [EB in B]: O[KO] }>
-        : Expanded<O[KO]>;
-    }
-  : O;
-
-/**
- * Union type of the types of the values in `T`
- * @internal
- */
-type ValueOf<T> = T extends Array<unknown> | ReadonlyArray<unknown> ? T[number] : T[keyof T];
-
-/**
- * Transforms a string to lowercase and the first character to uppercase.
- * @internal
- */
-type Titlecase<S extends string> = S extends `${infer A} ${infer B}`
-  ? `${Titlecase<A>} ${Titlecase<B>}`
-  : Capitalize<Lowercase<S>>;
-
-/**
- * Deeply merge two types. If either of the given types is not an `object`, `U`
- * simply overwrites `T`.
- *
- * Nested properties of type `object` are merged recursively unless the property
- * in `U` is an `Array`.
- *
- * @typeParam T - The base type that `U` will be merged into.
- * @typeParam U - The type that will be merged into `T`.
- */
-type Merge<T, U> = T extends object
-  ? U extends Array<any> | ReadonlyArray<any>
-    ? U
-    : U extends object
-    ? {
-        [Key in keyof T | keyof U]: Key extends keyof T
-          ? Key extends keyof U
-            ? Merge<T[Key], U[Key]>
-            : T[Key]
-          : Key extends keyof U
-          ? U[Key]
-          : never;
-      }
-    : U
-  : U;
-
-/**
- * If `T` is `Promise<TResult>` then `TResult`; otherwise `T`.
- * @typeParam T - the type which, if a Promise, will be unwrapped.
- */
-type PromisedType<T> = T extends Promise<infer TResult> ? TResult : T;
-
-type StoredDocument<D extends { data: { _source: unknown } }> = D & {
-  id: string;
-  data: D['data'] & {
-    _id: string;
-    _source: D['data']['_source'] & { _id: string };
-  };
-};
-
-type TemporaryDocument<D> = D extends StoredDocument<infer U> ? U : D;
-
-type PropertyTypeOrFallback<T, Key extends string, Fallback> = Key extends keyof T ? T[Key] : Fallback;
-
-/**
- * Makes the given keys `K` of the type `T` required
- */
-type RequiredProps<T, K extends keyof T> = Required<Pick<T, K>> & Omit<T, K>;