Class DetectionModeTremor

_source

parent

Static _detectionFilter

Static LOCALIZATION_PREFIXES

schema

• get schema(): SchemaField

• Define the data schema for this document instance.

  Returns SchemaField

invalid

• get invalid(): boolean

• Is the current state of this DataModel invalid? The model is invalid if there is any unresolved failure.

  Returns boolean

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

Static schema

• get schema(): SchemaField

• The Data Schema for all instances of this DataModel.

  Returns SchemaField

testVisibility

• testVisibility(visionSource, mode, config?): boolean

• Test visibility of a target object or array of points for a specific vision source.

  Parameters

  • visionSource: VisionSource

    The vision source being tested
  • mode: TokenDetectionMode

    The detection mode configuration
  • config: CanvasVisibilityTestConfig = {}

    The visibility test configuration

  Returns boolean

  Is the test target visible?

reset

• reset(): void

• Reset the state of this data instance back to mirror the contained source data, erasing any changes.

  Returns void

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

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

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

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

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

Static defineSchema

• defineSchema(): {
      id: StringField;
      label: StringField;
      tokenConfig: BooleanField;
      walls: BooleanField;
      angle: BooleanField;
      type: NumberField;
  }

• 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;
      label: StringField;
      tokenConfig: BooleanField;
      walls: BooleanField;
      angle: BooleanField;
      type: NumberField;
  }

  • id: StringField

  • label: StringField

  • tokenConfig: BooleanField

  • walls: BooleanField

  • angle: BooleanField

  • type: NumberField

Static cleanData

• cleanData(source?, options?): object

• Clean a data source object to conform to a specific provided schema.

  Parameters

  • Optional source: object = {}

    The source data object
  • Optional options: object = {}

    Additional options which are passed to field cleaning methods

  Returns object

  The cleaned source data

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

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

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

Static migrateData

• migrateData(source): object

• Migrate candidate source data for this DataModel which may require initial cleaning or transformations.

  Parameters

  • source: object

    The candidate source data from which the model will be constructed

  Returns object

  Migrated source data, if necessary

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

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