Class BasePackage

The data schema used to define a Package manifest. Specific types of packages extend this schema with additional fields.

Hierarchy (view full)

DataModel
- BasePackage

Constructors

constructor

new BasePackage(data, options?): BasePackage
Parameters
- data: PackageManifestData
  Source data for the package
- Optional options: object = {}
  Options which affect DataModel construction
Returns BasePackage
Overrides DataModel.constructor

Properties

availability

availability: number

An availability code in PACKAGE_AVAILABILITY_CODES which defines whether this package can be used.

locked

locked: boolean

A flag which tracks whether this package is currently locked.

exclusive

exclusive: boolean

A flag which tracks whether this package is a free Exclusive pack

owned

owned: boolean

A flag which tracks whether this package is owned, if it is protected.

hasStorage

hasStorage: boolean

A flag which tracks if this package has files stored in the persistent storage folder

_source

_source: object

The source data object for this DataModel instance. Once constructed, the source object is sealed such that no keys may be added nor removed.

parent

parent: DataModel

An immutable reverse-reference to a parent DataModel to which this model belongs.

`Static` type

type: string = "package"

Define the package type in CONST.PACKAGE_TYPES that this class represents. Each BasePackage subclass must define this attribute.

`Static` migratedKeys

migratedKeys: Set<string> = ...

A set of package manifest keys that are migrated.

`Static` LOCALIZATION_PREFIXES

LOCALIZATION_PREFIXES: string[] = []

A set of localization prefix paths which are used by this DataModel.

Accessors

type

get type(): string
The type of this package instance. A value in CONST.PACKAGE_TYPES.

Returns string

name

get name(): string
The canonical identifier for this package

Returns string
Deprecated

unavailable

get unavailable(): boolean
A flag which defines whether this package is unavailable to be used.

Returns boolean

incompatibleWithCoreVersion

get incompatibleWithCoreVersion(): boolean
Is this Package incompatible with the currently installed core Foundry VTT software version?

Returns boolean

schema

get schema(): SchemaField
Define the data schema for this document instance.

Returns SchemaField
Inherited from DataModel.schema

invalid

get invalid(): boolean
Is the current state of this DataModel invalid? The model is invalid if there is any unresolved failure.

Returns boolean
Inherited from DataModel.invalid

validationFailures

get validationFailures(): {
fields: DataModelValidationFailure;
joint: DataModelValidationFailure;
}
An array of validation failure instances which may have occurred when this instance was last validated.

Returns {
fields: DataModelValidationFailure;
joint: DataModelValidationFailure;
}
- fields: DataModelValidationFailure
- joint: DataModelValidationFailure
Inherited from DataModel.validationFailures

`Static` collection

get collection(): string
The named collection to which this package type belongs

Returns string

`Static` schema

get schema(): SchemaField
The Data Schema for all instances of this DataModel.

Returns SchemaField
Inherited from DataModel.schema

Methods

_testRequiredDependencies

_testRequiredDependencies(modulesCollection): Promise<boolean>
Internal
Test that the dependencies of a package are satisfied as compatible. This method assumes that all packages in modulesCollection have already had their own availability tested.
Parameters
- modulesCollection: Collection<string, Module>
  A collection which defines the set of available modules
Returns Promise<boolean>
Are all required dependencies satisfied?

_testSupportedSystems

_testSupportedSystems(systemCollection): Promise<boolean>
Internal
Test compatibility of a package's supported systems.
Parameters
- systemCollection: Collection<string, System>
  A collection which defines the set of available systems.
Returns Promise<boolean>
True if all supported systems which are currently installed are compatible or if the package has no supported systems. Returns false otherwise, or if no supported systems are installed.

reset

reset(): void
Reset the state of this data instance back to mirror the contained source data, erasing any changes.

Returns void
Inherited from DataModel.reset

clone

clone(data?, context?): Document | Promise<Document>
Clone a model, creating a new data model by combining current data with provided overrides.
Parameters
- Optional data: Object = {}
  Additional data which overrides current document data at the time of creation
- Optional context: object = {}
  Context options passed to the data model constructor
Returns Document | Promise<Document>
The cloned Document instance

Inherited from DataModel.clone

validate

validate(options?): boolean
Validate the data contained in the document to check for type and content This function throws an error if data within the document is not valid
Parameters
- options: {
      changes: object;
      clean: boolean;
      fallback: boolean;
      dropInvalidEmbedded: boolean;
      strict: boolean;
      fields: boolean;
      joint: boolean;
  } = {}
  Optional parameters which customize how validation occurs.
  - changes: object
    A specific set of proposed changes to validate, rather than the full source data of the model.
  - clean: boolean
    If changes are provided, attempt to clean the changes before validating them?
  - fallback: boolean
    Allow replacement of invalid values with valid defaults?
  - dropInvalidEmbedded: boolean
    If true, invalid embedded documents will emit a warning and be placed in the invalidDocuments collection rather than causing the parent to be considered invalid.
  - strict: boolean
    Throw if an invalid value is encountered, otherwise log a warning?
  - fields: boolean
    Perform validation on individual fields?
  - joint: boolean
    Perform joint validation on the full data model? Joint validation will be performed by default if no changes are passed. Joint validation will be disabled by default if changes are passed. Joint validation can be performed on a complete set of changes (for example testing a complete data model) by explicitly passing true.
Returns boolean
An indicator for whether the document contains valid data

Inherited from DataModel.validate

updateSource

updateSource(changes?, options?): object
Update the DataModel locally by applying an object of changes to its source data. The provided changes are cleaned, validated, and stored to the source data object for this model. The source data is then re-initialized to apply those changes to the prepared data. The method returns an object of differential changes which modified the original data.
Parameters
- changes: object = {}
  New values which should be applied to the data model
- Optional options: object = {}
  Options which determine how the new data is merged
Returns object
An object containing the changed keys and values

Inherited from DataModel.updateSource

toObject

toObject(source?): object
Copy and transform the DataModel into a plain object. Draw the values of the extracted object from the data source (by default) otherwise from its transformed values.
Parameters
- Optional source: boolean = true
  Draw values from the underlying data source rather than transformed values
Returns object
The extracted primitive object

Inherited from DataModel.toObject

toJSON

toJSON(): object
Extract the source data for the DataModel into a simple object format that can be serialized.

Returns object
The document source data expressed as a plain object

Inherited from DataModel.toJSON

`Protected` _configure

_configure(options?): void
Protected
Configure the data model instance before validation and initialization workflows are performed.
Parameters
- options: {} = {}
Returns void
Inherited from DataModel._configure

`Protected` _initializeSource

_initializeSource(data, options?): object
Protected
Initialize the source data for a new DataModel instance. One-time migrations and initial cleaning operations are applied to the source data.
Parameters
- data: object | DataModel
  The candidate source data from which the model will be constructed
- Optional options: object = {}
  Options provided to the model constructor
Returns object
Migrated and cleaned source data which will be stored to the model instance

Inherited from DataModel._initializeSource

`Protected` _initialize

_initialize(options?): void
Protected
Initialize the instance by copying data from the source object to instance attributes. This mirrors the workflow of SchemaField#initialize but with some added functionality.
Parameters
- Optional options: object = {}
  Options provided to the model constructor
Returns void
Inherited from DataModel._initialize

`Static` isIncompatibleWithCoreVersion

isIncompatibleWithCoreVersion(availability): boolean
Test if a given availability is incompatible with the core version.
Parameters
- availability: number
  The availability value to test.
Returns boolean

`Static` defineSchema

defineSchema(): {
    id: StringField;
    title: StringField;
    description: StringField;
    authors: SetField;
    url: StringField;
    license: StringField;
    readme: StringField;
    bugs: StringField;
    changelog: StringField;
    flags: ObjectField;
    media: SetField;
    version: StringField;
    compatibility: PackageCompatibility;
    scripts: SetField;
    esmodules: SetField;
    styles: SetField;
    languages: SetField;
    packs: PackageCompendiumPacks;
    packFolders: SetField;
    relationships: PackageRelationships;
    socket: BooleanField;
    manifest: StringField;
    download: StringField;
    protected: BooleanField;
    exclusive: BooleanField;
    persistentStorage: BooleanField;
}
Define the data schema for documents of this type. The schema is populated the first time it is accessed and cached for future reuse.

Returns {
    id: StringField;
    title: StringField;
    description: StringField;
    authors: SetField;
    url: StringField;
    license: StringField;
    readme: StringField;
    bugs: StringField;
    changelog: StringField;
    flags: ObjectField;
    media: SetField;
    version: StringField;
    compatibility: PackageCompatibility;
    scripts: SetField;
    esmodules: SetField;
    styles: SetField;
    languages: SetField;
    packs: PackageCompendiumPacks;
    packFolders: SetField;
    relationships: PackageRelationships;
    socket: BooleanField;
    manifest: StringField;
    download: StringField;
    protected: BooleanField;
    exclusive: BooleanField;
    persistentStorage: BooleanField;
}
- id: StringField
- title: StringField
- description: StringField
- authors: SetField
- url: StringField
- license: StringField
- readme: StringField
- bugs: StringField
- changelog: StringField
- flags: ObjectField
- media: SetField
- version: StringField
- compatibility: PackageCompatibility
- scripts: SetField
- esmodules: SetField
- styles: SetField
- languages: SetField
- packs: PackageCompendiumPacks
- packFolders: SetField
- relationships: PackageRelationships
- socket: BooleanField
- manifest: StringField
- download: StringField
- protected: BooleanField
- exclusive: BooleanField
- persistentStorage: BooleanField
Overrides DataModel.defineSchema

`Static` testAvailability

testAvailability(data, options?): number
Check the given compatibility data against the current installation state and determine its availability.
Parameters
- data: PackageManifestData
  The compatibility data to test.
- Optional options: {
  release: ReleaseData;
  } = {}
  - release: ReleaseData
    A specific software release for which to test availability. Tests against the current release by default.
Returns number

`Static` testDependencyCompatibility

testDependencyCompatibility(compatibility, dependency): boolean
Determine if a dependency is within the given compatibility range.
Parameters
- compatibility: PackageCompatibility
  The compatibility range declared for the dependency, if any
- dependency: BasePackage
  The known dependency package
Returns boolean
Is the dependency compatible with the required range?

`Static` cleanData

cleanData(source?, __namedParameters?): object
Clean a data source object to conform to a specific provided schema.
Parameters
- source: {} = {}
  The source data object
- __namedParameters: {
  installed: any;
  } = {}
  Additional options which are passed to field cleaning methods
  - installed: any
Returns object
The cleaned source data

Overrides DataModel.cleanData

`Static` validateId

validateId(id): void
Validate that a Package ID is allowed.
Parameters
- id: string
  The candidate ID
Returns void
Throws
An error if the candidate ID is invalid

`Static` _logWarning

_logWarning(packageId, message, options?): void
Internal
A wrapper around the default compatibility warning logger which handles some package-specific interactions.
Parameters
- packageId: string
  The package ID being logged
- message: string
  The warning or error being logged
- options: {
  installed: object;
  } = {}
  Logging options passed to foundry.utils.logCompatibilityWarning
  - installed: object
    Is the package installed?
Returns void

`Static` migrateData

migrateData(data, __namedParameters?): object
Migrate candidate source data for this DataModel which may require initial cleaning or transformations.
Parameters
- data: any
  The candidate source data from which the model will be constructed
- __namedParameters: {
  installed: any;
  } = {}
  - installed: any
Returns object
Migrated source data, if necessary

Overrides DataModel.migrateData

`Static` _migrateNameToId

_migrateNameToId(data, logOptions): void
Internal
Parameters
- data: any
- logOptions: any
Returns void

`Static` _migrateDependenciesNameToId

_migrateDependenciesNameToId(data, logOptions): void
Internal
Parameters
- data: any
- logOptions: any
Returns void

`Static` _migrateToRelationships

_migrateToRelationships(data, logOptions): void
Internal
Parameters
- data: any
- logOptions: any
Returns void

`Static` _migrateCompatibility

_migrateCompatibility(data, logOptions): void
Internal
Parameters
- data: any
- logOptions: any
Returns void

`Static` _migrateMediaURL

_migrateMediaURL(data, logOptions): void
Internal
Parameters
- data: any
- logOptions: any
Returns void

`Static` _migrateOwnership

_migrateOwnership(data, logOptions): any
Internal
Parameters
- data: any
- logOptions: any
Returns any

`Static` _migratePackIDs

_migratePackIDs(data, logOptions): void
Internal
Parameters
- data: any
- logOptions: any
Returns void

`Static` _migratePackEntityToType

_migratePackEntityToType(data, logOptions): void
Internal
Parameters
- data: any
- logOptions: any
Returns void

`Static` fromRemoteManifest

fromRemoteManifest(manifestUrl, options?): Promise<ServerPackage>
Retrieve the latest Package manifest from a provided remote location.
Parameters
- manifestUrl: string
  A remote manifest URL to load
- options: {
  strict: boolean;
  } = {}
  Additional options which affect package construction
  - strict: boolean
    Whether to construct the remote package strictly
Returns Promise<ServerPackage>
A Promise which resolves to a constructed ServerPackage instance

Throws
An error if the retrieved manifest data is invalid

`Static` validateJoint

validateJoint(data): any
Evaluate joint validation rules which apply validation conditions across multiple fields of the model. Field-specific validation rules should be defined as part of the DataSchema for the model. This method allows for testing aggregate rules which impose requirements on the overall model.
Parameters
- data: object
  Candidate data for the model
Returns any
Throws
An error if a validation failure is detected

Inherited from DataModel.validateJoint

`Static` fromSource

fromSource(source, context?): DataModel
Create a new instance of this DataModel from a source record. The source is presumed to be trustworthy and is not strictly validated.
Parameters
- source: object
  Initial document data which comes from a trusted source.
- Optional context: any = {}
  Model construction context
Returns DataModel
Inherited from DataModel.fromSource

`Static` fromJSON

fromJSON(json): DataModel
Create a DataModel instance using a provided serialized JSON string.
Parameters
- json: string
  Serialized document data in string format
Returns DataModel
A constructed data model instance

Inherited from DataModel.fromJSON

`Static` migrateDataSafe

migrateDataSafe(source): object
Wrap data migration in a try/catch which attempts it safely
Parameters
- source: object
  The candidate source data from which the model will be constructed
Returns object
Migrated source data, if necessary

Inherited from DataModel.migrateDataSafe

`Static` shimData

shimData(data, options?): object
Take data which conforms to the current data schema and add backwards-compatible accessors to it in order to support older code which uses this data.
Parameters
- data: object
  Data which matches the current schema
- Optional options: {
  embedded: boolean;
  } = {}
  Additional shimming options
  - embedded: boolean
    Apply shims to embedded models?
Returns object
Data with added backwards-compatible properties

Inherited from DataModel.shimData

`Static` `Protected` _initializationOrder

_initializationOrder(): Generator<[string, DataField], any, any>
Protected
A generator that orders the DataFields in the DataSchema into an expected initialization order.

Returns Generator<[string, DataField], any, any>
Inherited from DataModel._initializationOrder

`Static` `Private` #validatePack

#validatePack(packData): void
Validate a single compendium pack object
Parameters
- packData: PackageCompendiumData
  Candidate compendium packs data
Returns void
Throws
An error if the data is invalid

Class BasePackage

Hierarchy (view full)

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

Returns BasePackage

Properties

availability

locked

exclusive

owned

tags

hasStorage

_source

parent

Static type

Static migratedKeys

Static LOCALIZATION_PREFIXES

Accessors

type

Returns string

name

Returns string

Deprecated

unavailable

Returns boolean

incompatibleWithCoreVersion

Returns boolean

schema

Returns SchemaField

invalid

Returns boolean

validationFailures

Returns { fields: DataModelValidationFailure; joint: DataModelValidationFailure; }

fields: DataModelValidationFailure

joint: DataModelValidationFailure

Static collection

Returns string

Static schema

Returns SchemaField

Methods

_testRequiredDependencies

Parameters

Returns Promise<boolean>

_testSupportedSystems

Parameters

Returns Promise<boolean>

reset

Returns void

clone

Parameters

Returns Document | Promise<Document>

validate

Parameters

changes: object

clean: boolean

fallback: boolean

dropInvalidEmbedded: boolean

strict: boolean

fields: boolean

joint: boolean

Returns boolean

updateSource

Parameters

Returns object

toObject

Parameters

Returns object

toJSON

Returns object

Protected _configure

Parameters

Returns void

Protected _initializeSource

Parameters

`Static` type

`Static` migratedKeys

`Static` LOCALIZATION_PREFIXES

Returns {
fields: DataModelValidationFailure;
joint: DataModelValidationFailure;
}

`Static` collection

`Static` schema

`Protected` _configure

`Protected` _initializeSource

`Protected` _initialize

`Static` isIncompatibleWithCoreVersion

`Static` defineSchema

`Static` testAvailability

`Static` testDependencyCompatibility

`Static` cleanData

`Static` validateId

`Static` _logWarning

`Static` migrateData

`Static` _migrateNameToId

`Static` _migrateDependenciesNameToId

`Static` _migrateToRelationships

`Static` _migrateCompatibility