acType referenceacType methodscreateModel()createComboOption()comboOptionInfo()createOption()displayableOptions()externalModels()findInternalModels()getModelData()getOptionData()getOptionInfo()getSelector()getSelectorOption()hasOption()init()isApplicable()isInSerialNums()isModel()isSelectorClass()isValidSerialNumber()models()modelTitle()newName()optionConflicts()optionDataConflicts()optionInfo()optionUseSelector()renderAvailableDataSources()renderOptionRows()renderSourceList()restoreAcData()selectOption()setAcData()setSelectorOption()setTypeData()unselectOption()The acType object controls the presentation of aircraft data based on the selected aircraft model, serial number, and the selected options. The aircraft data may contain both data and methods. The data for the currently selected aircraft and options in assembled in the acData object. The acData object is global and does not need to be imported. It represents the POH data and the associated computation methods for a particular Pilot's Operating Handbook, Owner's Handbook, or Owner's Manua (we'll call all these POH), as amended by any Airplane Flight Manual Supplements (AFMS) for selected options.
Typically, the Aircraft page allows the user to configure and select aircraft and also sets the ac_data state variable to the contents of acData whenever a new model, serial number, or options are selected. This allows pages to use ac_data to trigger Model computations.
Each aircraft type (e.g., Beech Bonanza) may have several aircraft models (e.g., A36, V35, etc.). Sometimes, an aircraft model has more than one associated POH (e.g., Bonanza A36). The correct POH is selected by the serial number. The model name that the user associated with the aircraft (e.g., A36) is the "external" model. The set of data that is associated with a specific POH is the "internal" model. An internal model name is the external model name with a suffix consisting of a "#" followed by a string specifying the POH.
Serial numbers consist of an alphanumeric prefix that does not vary within the model and can be empty, followed by a numeric string that varies with individual aircraft.
Applicable serial number ranges are specified by a string containing the following elements:
${start}-$(end} specifying a continuous range of numbers that include start and end.${start}- specifying all the serial numbers greater than or equal to start.The isInSerialNums() method tests whether a specific serial number (without the prefix) falls within a serial number range string. The isValidSerialNumber() method return true if the serial number is valid for a particular internal model ID.
A model serial number can have a fixed width. If it does, the numeric part of the serial number may be extended with leading zeros as required. The serial numbers in serial number range strings need not contain leading zeros.
Models are created by calling acType.createModel(), which takes an info object as a parameter. The object contains the following properties:
modelIdC172S); if there is more than one POH associated with the external name, then a suffix is used to differentiate this data (e.g., 'A36#2').titleserialFixedWidthserialNumbersserialPrefixserialWidthserialFixedWidth is also set, it overrides this value.datasetTypeData() — type-wide data is merged under every model automatically. Use a function form when it is inconvenient to declare the object at file-load time or when individual properties need to be resolved via UseValue. The function takes no arguments. (See createOption() for the analogous function form for options, which receives the base model data as an argument.)In POH Performance aircraft apps, the Aircraft page imports all the relevant model files to cause them to be loaded. This means that the aircraft models are already defined when the page's init() method is called, at which time the model selector state variable can be configured.
Some aircraft data applies across all types that the app supports. Examples of type-wide data are risk parameters, the aircraft icon, the fuel type, and default methods, etc. These properties are included in all assembled aircraft data in acData. The type-wide data is set by calling acType.setTypeData(). The type-wide data can be overridden by the data in selected models or options if required.
Type-wide methods (e.g. tko.roll, climb.rate, ldg.roll) defined via setTypeData() form the base methods for every model in the type. A model file does not need to call modelDataMergeUnder() or otherwise re-declare these methods to get them — acType.init() merges each model's data over a copy of the type-wide data once at startup, and acType.setAcData() then copies that merged data. A model only needs to declare a method if it wants to override the type-wide default.
This automatic merging is also why option data functions receive a modelData argument that already contains the type-wide base methods: see Merging option data.
The type-wide data may include a type-specific data merge method mergeModelData which has the signature:
mergeModelData(target, ...sources)
If no mergeModelData method is provided, then objectOverlay() is used. The acType.init() method uses it to merge each model's data into a copy of the type-wide data once at startup. The acType.setAcData() method copies that merged model data to build the current aircraft object in acData, and uses the same method to merge data for the installed options into it.
The type-wide data may also include an isModelDataConflict(data1, data2) function. Installing options calls it to decide whether the data of two installed options conflict, and asserts if so. If it is absent, two option data objects conflict when they share any top-level key. A type can supply its own function to judge conflicts on nested keys. The function is read from the aircraft data (acData), so it only takes effect through the type-wide data.
If the aircraft data contains nested objects that must be overridden instead of overlayed when aircraft data is merged, then a mergeModelData method must be provided. Often, this method utilizes objectMergePathsOver() to merge only specific nested objects.
Options are optional features that either have a separate AFMS or are embedded in the POH. Each option has an ID and separate data and methods that modify the base data and methods of the aircraft model they are applied to. Each option is identified by an option ID string and has an associated data object containing the modifications to the base model data.
Like model IDs, option IDs can have internal and external versions in cases where the same selected option has different data depending on the model or serial number. Like model IDs, the external and internal parts of the ID string are separated by "#". Each defined option must have a unique internal ID. Each internal option ID must apply to a unique combination of model and serial number. It is an error for a selected external option ID in a given aircraft to apply to more than one internal option ID.
Options are restricted to apply to a specified set of model IDs and serial numbers. These are specified by an applicability string composed of ${modelId}:${serialNumRange}. The modelId is an internal model ID or a RegExp string (without the surrounding '/'), and serialNumRange is a serial number range string or '-' that matches all serial numbers for the matching model IDs. Multiple models and serial ranges can be specified by separating them with a ';'. For example: A36#2:- matches all serial numbers associated the second A36 POH, and A36:-;G36:- or [AG]36:- match all serial numbers in all A36 and G36 POHs. Remember that the modelId being a RegExp can have unexpected effects if some model IDs are substrings of other model IDs. In some cases, it might be best to surround the model ID string with '^' and '$' as in ^[AG]36$:-.
Options are created by calling acType.createOption(), which takes an info object as a parameter. The object contains some of the following properties:
titletitleTip (optional)optionIdoptClassdata (optional)(modelData) => ({...}) that returns such an object. The function form is the right choice whenever the option needs to refer to the underlying model data — most commonly to call a base method that the option wraps. See Merging option data for the function-form pattern.order (optional)data are merged. Lower numbers are merged first. If order is omitted, then the option is merged after all options that provide an order.overrides (optional)disabled (optional)The info object must also contain one of the following properties. It may contain both:
optionOninstalledOnWhen an option is installed, its info.data property is retrieved and merged over the current model data. The options are merged in the order specified by info.order: options with the lowest numeric value of info.order are merged first, options that don't specify an order are merged last. An option that names another in info.overrides is always merged after it, whatever the order values.
info.data may be either an object or a function:
Object form — a plain object describing the overrides. Use this when the option just supplies replacement data and does not need to reference anything from the underlying model.
Function form — (modelData) => ({...}). The function is called with modelData, an image of the base model data with the type-wide data already merged in (i.e. what acType.getModelData(modelId) returns). The function returns the object to merge over the model data.
Use the function form whenever the option needs to look at, or build on top of, the underlying model — most commonly when an option's method wraps a base method (multiply takeoff distance by a weight factor, add an offset to climb rate, etc.). Inside the override method, call the base implementation via modelData.<area>.<method>(...).
Example — a gross-weight-increase option that scales the takeoff ground roll by a weight factor:
acType.createOption({
title: `D'Shannon gross-weight increase`,
optionId: 'DSgwi#A36',
optionOn: 'A36:-',
optClass: 'GWI',
data: (modelData) => ({
wb: {maxTkoWeight: 3850, maxLdgWeight: 3850},
tko: {
// New table; consumed by the roll() override below.
distWeightFactorTbl: new Ptable({
title: `Takeoff distance weight adjustment factor`,
inputs: [{key:'weight', limit:'clamp'}],
output: {key:'factor'},
a: [
{p:0, v:1},
{p:3600, v:1},
{p:3850, v:1.15},
],
}),
// Call the base roll() (from modelData) and scale by the new table.
roll (conditions) {
const dist = modelData.tko.roll(conditions);
if (isError(dist)) return (dist);
return (dist * acData.tko.distWeightFactorTbl.interpolate(conditions));
},
},
}),
});
Note modelData (passed in) vs acData (the global, fully-assembled current aircraft). The override calls modelData.tko.roll(...) to reach the base roll without infinite recursion — the override itself is about to become acData.tko.roll once the merge completes. New tables introduced by this option, on the other hand, are read off acData because they only exist after the merge.
A data function can also choose to build its return value by composing helpers like objectMergePathsOver() over modelData and a literal overlay.
UseValue instancesAn option can set the value of a key to a UseValue instance. This allows an option to build a custom value for a specific key. For example, to add a new weight point for a gross weight increase. Assume the model data contains the following property:
glideCasTbl: new Ptable({
title: `Glide CAS`,
inputs: [{key:'weight', limit:'clampLo'},],
output: {key:'ias', rndMult:1},
a: [
{p:2100, v:63},
{p:2600, v:73},
{p:3100, v:78},
],
}),
Then, one could write the options property for a gross weight increase to 3,200 lb as:
glideCasTbl: new UseValue((obj, modelData) => {
const table = modelData.glideCasTbl;
oldMaxWeight = table.a.at(-1).p;
oldCas = table.a.at(-1).v;
table.a.push({
p: 3200,
v: round(weightAdjustCas(oldCas, oldMaxWeight, 3200))
}),
return (table);
})
In POH Performance apps, the Aircraft page allows the user to define and edit a list of aircraft. Each defined aircraft has a selected model within the aircraft type and serial number, along with a set of selected options. Once selected, the Aircraft page calls acType.setAcData() to set up acData according to the selected model, serial number, and options. acType.setAcData() builds the contents of acData by copying the selected model's data (which acType.init() already merged over the type-wide data), then merging the data objects of the installed options. If the serial number is not valid for the model (e.g., it is zero), it substitutes a default: the last serial number in the model's range, since the first aircraft are often development outliers. If the external model ID has several internal models and the serial number does not select one, it uses the internal model with isDefaultModel set, or else the latest. In addition, it adds the following acData properties:
dataSourcesmodelIdmodelId for this data.optionsallavailableoptionOn or installedOn criteria.comboscreateComboOption()). Combination options are internal: they never appear in installed or selectable, but they can be tested with hasOption().installedincludes criteria of another installed option.permanentinstalledOn criteria, and options included by another installed option. A permanent option is not permanent if another option in its option class is selected.selectableoptionOn criteria. However, options that have been disabled by the optClass, incompatibleWith, or enabledBy criteria or have been automatically selected by meeting the includes criteria for another installed option are excluded.serialNumsetAcData() if it is valid for the model, otherwise the default serial number (see above). Use acType.isValidSerialNumber() to check a serial number.titleThe user interface to select options is usually on the Aircraft page. The page can use acType.renderOptionRows() to display the options associated with the currently selected aircraft model as <Cr> components.
acType.renderOptionRows() only displays the options in the acData.options.available array. Options not in the acData.options.selectable array are disabled and greyed out, letting the user know that other selections have disabled them.
Options in the same option class exclude one another, so offering a checkbox for each is awkward: the user has to clear the installed option before any other becomes selectable. acType.optionUseSelector() marks a whole class to be presented as a single selector instead:
acType.optionUseSelector('Seats', 'Seat type');
acType.renderOptionRows() then draws one row for the class in place of the individual checkboxes, labelled with the title passed to acType.optionUseSelector(). Where the application would rather place the selector itself — beside a diagram the options affect, for example — acType.getSelector() returns the same selector as a component that can be placed anywhere. In that case leave the class's options out of every display group, so the generated option card does not offer them a second time.
The choices are the class's available options in display order, each labelled with the option's title and valued with its option ID. Choosing one installs it and uninstalls the class member it replaces in a single step: a member of the class being installed makes its siblings unselectable, so acType.selectOption() cannot be used to move between them.
If one of the class's options is installed by default on the model (its installedOn applies), the selector always shows a choice, and picking that option simply clears the class rather than selecting it as well. Otherwise the selector also offers an empty choice while none of the class is installed, since that is a real state in which the model's own data applies.
When two or more options are to be installed, it's possible that they each try to modify the same properties. This is disallowed and will produce a conflict assertion failure. In addition, some options are incompatible with other options even if they don't produce a conflict. There are several ways to prevent this. The first is the option class: Each option can belong to one or more option classes. Only one option from each class can be installed. The optClass property in the info object contains an array of option class ID strings that the option belongs to. For example, an engine upgrade can belong to option classes 'Eng' and 'GWI' if it provides both an engine upgrade and gross weight increase. If this engine upgrade option is selected, then all other engine upgrades or gross weight increase options are removed from the selectable list.
Like a model ID, an option ID can contain a suffix consisting of a "#" followed by a string specifying a variant of an option. The base (prefix) part of the option ID forms an implicit option class ID. For example, option ID option1#variant1 will define an class ID of option1 in addition to any other class ID defined by optClass. This means that only one option variant is selectable or installed.
Sometimes two options are meant to modify the same property, because one supersedes the other: an STC that replaces a CG envelope installed on the same serial numbers, for example. The overrides property in the info object contains an option ID string, or an array of them, whose data this option replaces. Both options stay installed — so the properties the overriding option doesn't provide still apply — but the pair is exempt from the conflict assertion, and the overriding option is merged last so its values win. Use overrides when both options' data are wanted; use optClass or incompatibleWith when only one of them should be installed.
Sometimes two individually selectable options genuinely install together, but each replaces some of the same properties — oversize tires and a cargo compartment that both publish a go-around weight limit, for example. Rather than making the user select a third, manually combined option (appropriate when the combination itself is a user decision, such as a choice between two W&B envelopes), declare a combination option with createComboOption(). A combination option is internal — never displayed, selected, or stored. When every option in its combines list is installed, the members merge as one unit in combines order, followed by the combination option's own data (the fixup for the combined configuration), and the conflict assertion is suppressed among the members. Everything else still asserts, so an undeclared conflicting pair remains an error. When several combination options match, larger member sets win and subsumed ones are skipped; a partial overlap between two applicable combination options asserts — declare a combination option for the full set instead.
Sometimes, selecting an option conflicts with a specific set of other options. The incompatibleWith property in the info object contains an array of option ID strings for options that are incompatible with this one. If this option is selected, the listed options will be removed from the selectable and installed list, and if any option in the list is selected, then this option will also be removed from the selectable list. The incompatibleWith property will allow a selected option to override an installed option, for example, to provide an upgraded replacement for a manufacturer-installed device.
Sometimes an option depends on other options being installed. The enabledBy property in the info object contains an array of option ID strings for options that must be installed if this option is to be visible. If none of the enabling options in the list are installed, then this option is removed from the selectable list. It stays in the available list, so it is displayed disabled (greyed out). Use enabledBy when the option is obviously related to its dependencies, such that the user should see that it can't be selected until a dependency is. For example, a turbulence detection option that is dependent on radar being installed.
Alternatively, the includes property in the info object contains an array of option ID strings for options that must be installed if this option is selected. The option remains visible. If the option is selected then all the options in the list are automatically selected and removed from the selectable list so that they cannot be deselected. Use includes when the option is not obviously related to its dependencies so that it makes sence to have the option visible even when its dependencies are not selected. For example, when seat heaters are dependent on a particular interior package and the user may not be aware of the dependency.
acDataimport {acData} from 'common/aero/export.js';
The acData object contains the properties and methods that represent the currently selected aircraft model and serial number, as amended by the installed options. The acData object is also a global identifier and does not require an explicit import.
acTypeimport {acType} from 'common/aero/export.js';
The acType object contains the properties and methods used to control the currently active aircraft data and define aircraft models and options.
baseId()import {baseId} from 'common/aero/export.js';
baseId(id)
Returns the external (base) part of an internal model or option ID: the ID with any # suffix removed (e.g., 'A36#2' returns 'A36').
hasIdSuffix()import {hasIdSuffix} from 'common/aero/export.js';
hasIdSuffix(id)
Returns true if the internal model or option ID has a # suffix.
serialPrefixFor()import {serialPrefixFor} from 'common/aero/export.js';
serialPrefixFor()
serialPrefixFor(serialNum)
serialPrefixFor(serialNum, modelInfo)
Returns the serial number prefix string for serialNum (default acData.serialNum) according to modelInfo (default acData). If modelInfo.serialPrefix is a string, it is returned. If it is an object that maps serial number ranges to prefixes, the prefix for the range containing serialNum is returned, or the first range's prefix if none contains it. An absent prefix returns ''.
toFixedWidth()import {toFixedWidth} from 'common/aero/export.js';
toFixedWidth(value, width)
Converts value to a string of exactly width characters, padded with leading zeros. If the value is too long, its leading digits are kept.
unpadded()import {unpadded} from 'common/aero/export.js';
unpadded(serialNum)
Returns the serial number as a string with any leading zeros removed (e.g., one saved while its model had a fixed width). A serial number of all zeros returns '0'.
acType methodscreateModel()acType.createModel(info)
This function defines a new aircraft model according to the info object. All aircraft models should be defined when the application is loaded, but in any case, before acType.init() is called on startup.
infomodelIdC172S); if there is more than one POH associated with the external name, then a suffix is used to differentiate this data (e.g., 'A36#2').titledataSourceacData.dataSources.isDefaultModel (optional)serialFixedWidthserialNumbersserialPrefix{'1-5000':'28-', '5001-':'28-79'}). The object's keys must be the same ranges as serialNumbers, or createModel() asserts. A serial number outside every range uses the first range's prefix. See serialPrefixFor().serialWidthserialFixedWidth is also set, it overrides this value.datasetTypeData() is automatically merged under the model, so data only needs to declare what differs from the type-wide defaults. Use a function form when it is inconvenient to declare the object at file-load time or when individual properties need to be resolved via UseValue. The function takes no arguments.createComboOption()acType.createComboOption(info)
This function defines a combination option: an internal option applied automatically whenever every option named in info.combines is installed. Use it when two or more individually selectable options are legitimately installed together but their data would conflict (see Conflicting options). The combination option is never displayed, selected, or stored in the selected-options state; the member options remain the user-facing choices.
When applied, the members merge as one unit at the earliest position any member holds in the installation order — internally in combines order — followed by the combination option's own data, which carries only the combined configuration's fixups (often nothing at all, when the combines order alone resolves the overlap). The pairwise conflict assertion is suppressed among the members; the combination option's own data may only touch properties its members supply.
Applied combination options are listed in modelData.options.combos, may be tested with hasOption(), and their dataSource is appended to the aircraft's data sources.
infocombinesExternalCargo#K100) match their base name.data (optional)(modelData) => ({...}) as for createOption(). Merged after the members.dataSource (optional)optionId+ (e.g. LargeTires+ExternalCargo), optionally with a '#' variant suffix when different models need different combined data; variants are disambiguated by optionOn.optionOn (optional)None.
comboOptionInfo()acType.comboOptionInfo(optId)
This function returns the info object that combination option optId was created with (see acType.createComboOption()). It asserts if the combination option ID is not defined. It is intended for the option self-tests.
optIdThe combination option's info object.
createOption()acType.createOption(info)
This function defines a new aircraft option according to the info object. The option is identified by the internal option ID in info.optionId. info.data describes how the option modifies the base model data: it can be a plain object that is merged over the model data, or a function (modelData) => ({...}) that is called with the base model data and returns the object to merge. See Merging option data for guidance on when to use each form.
All aircraft options should be defined when the application is loaded, but in any case, before acType.init() is called on startup.
infodata (optional)(modelData) => ({...}) that returns such an object. When the option overrides a base method and needs to call it (e.g. to wrap takeoff distance with a weight factor), use the function form and call the base via modelData.<area>.<method>(...). See Merging option data for a worked example. If data is omitted, no data is merged.disabled (optional)optionOn and installedOn match. Use it to withdraw an option whose data isn't ready for use without discarding its applicability strings.dataSource (optional)acData.dataSources when the option is permanently installed and shown next to the option when it is selected.displayGroup (optional)acType.renderOptionRows() to display options in related groups on the Aircraft page. If the Aircraft page uses display groups, then all options that have an optionOn property must have a displayGroup.displayOrder (optional)displayGroup. If two options don't have an displayOrder, then they are sorted by title. If one of two options have no displayOrder, then the one without the displayOrder is sorted later.enabledBy (optional)includes (optional)incompatibleWith (optional)installedOn (optional if optionOn is provided)optionOn or installedOn must be provided. However, both optionOn and installedOn may be provided.optClassoptionIdoptionOn (optional if installedOn is provided)optionOn or installedOn must be provided. However, both optionOn and installedOn may be provided.order (optional)data are merged. Lower numbers are merged first. If order is omitted, then the option is merged after all options that provide an order.overrides (optional)titletitleTip (optional)acType.renderOptionRows(). Clicking the icon shows the tip text as a notice.The info object must contain at least one or both of optionOn or installedOn properties
displayableOptions()acType.displayableOptions(modelDataSv)
acType.displayableOptions(modelDataSv, displayGroup)
This function returns the option IDs to display for the current model data, sorted into display order. The result is the argument for acType.renderOptionRows(). It starts with the options in modelDataSv.value.options.available, leaves out the permanent options (the user has no choice about them), and sorts them by info.displayOrder (lower values first; options without a displayOrder come after the ones that have one; equal or undefined values sort by option title). If displayGroup is present, then only options whose info.displayGroup matches it are returned. This allows the Aircraft page to group the options into cards (e.g., "Engine", "TipTanks").
modelDataSvdisplayGroup (optional)An array of option ID strings.
externalModels()acType.externalModels()
This function returns an array of external model ID strings. It filters the list of all defined internal model ID strings to extract the unique external IDs.
An array of model ID strings.
findInternalModels()acType.findInternalModels(extModelId, serialNum)
This function returns an array of internal model ID strings corresponding to the external model ID extModelId and serial number serialNum. If the serial number is valid and corresponds to a single model, then that model ID is returned. If the serial number doesn't correspond to any model with that external model ID, all the internal model IDs with the specified external model ID are returned.
extModelIdserialNumAn array of model ID strings.
getModelData()acType.getModelData(modelId)
This function returns the full model data without any options for the given internal modelId. This includes the type-wide data with the model data merged over it. Any uses of UseValue are resolved.
modelIdAn object containing the data for modelId merged over the type-wide data.
getOptionData()acType.getOptionData(optId, modelId)
This function returns the data associated with option optId as applied to model modelId. If info.data (see acType.createOption()) is a function, the function is called with the model data associated with modelId as an argument.
optionIdmodelIdAn object containing the data for optionId.
getOptionInfo()acType.getOptionInfo(extModelId)
acType.getOptionInfo(extModelId, serialNum)
acType.getOptionInfo(extModelId, serialNum, selectedOptions)
This function returns the options object that would be set in acData for the model, serial number, and selected options. See Selecting an aircraft model.
extModelIdserialNum (optional)selectedOptions (optional)The options object: an object with all, available, permanent, installed, selectable, and combos properties, each an array of option ID strings. See Selecting an aircraft model.
getSelector()acType.getSelector(optClass)
acType.getSelector(optClass, options)
This function returns a Template containing a selector for the options of an option class marked by acType.optionUseSelector(), so the selector can be placed anywhere rather than only in the rows produced by acType.renderOptionRows(). The selector shows the installed option of the class and installs the option the user chooses, as described in Presenting an option class as a selector.
The function returns an empty string when the current aircraft offers none of the class's options, so the caller can place it without testing the model first.
It is an error to call this function for an option class that has not been marked by acType.optionUseSelector().
optClassoptions (optional)modelDataSv (optional)sv.ac_data.selectedOptSv (optional)sv.ac_selectedOptions.valueOnly (optional)onUserChange (optional)(optId, apply). When the user picks an option, it is called instead of installing the option, with the chosen option ID and an apply function. Call apply() to install the option (and sync), or don't to reject the change. This lets a caller vet the change first.A Template containing a <Selector> component, or an empty string when the aircraft offers none of the class's options.
getSelectorOption()acType.getSelectorOption(optClass)
acType.getSelectorOption(optClass, options)
This function returns the option ID of the option of an option class that the aircraft currently has installed: the selected member of the class, or the class's default option when none is selected. It returns an empty string when neither applies.
optClassoptions (optional)modelDataSv and selectedOptSv properties described for acType.getSelector().An option ID string, or an empty string.
hasOption()acType.hasOption(optionExpr)
This function returns true if the aircraft has options installed according to an expression consisting of option IDs, spaces, and '&', '|', '^', and '!' representing logical AND, OR, XOR, and NOT, respectively. Parentheses may be used for grouping.
An option ID in the expression matches by base ID: Seats is true if any variant such as Seats#K100 is installed. If an ID contains a #, it must match the installed option ID exactly. IDs may also contain + (combination options, see createComboOption()) and -. Applied combination options in acData.options.combos match as well as installed options. In a compound expression, an ID that is not a defined option or base ID asserts.
optionExpr&, |, ^, and ! representing logical AND, OR, XOR, and NOT, respectively. Parentheses are used for grouping, along with spacing characters.A Boolean.
init()acType.init()
This function initializes acType and sets up default aircraft data in acData. This function should be called by app.js after the app is loaded but before calling ctl.startApp to ensure aircraft data is present while the app is being initialized.
acType.init() builds the data for each model once, merging the model's data over a copy of the type-wide data (using mergeModelData), adding the model's title, serial number properties and dataSource, and storing the result as the model's full data returned by getModelData().
isApplicable()acType.isApplicable(appStr)
acType.isApplicable(appStr, modelId)
acType.isApplicable(appStr, modelId, serialNum)
This function returns true if the internal model ID modelId and serial number serialNum apply to the applicability string appStr. If serialNum is '-', then modelId must match a model RegExp in appStr that has a serialnumber range of '-'. If modelId and serialNum are unspecified, the data from the current aircraft is used.
appStrmodelId (optional)acData.modelId is used.serialNum (optional)acData.serialNum is used.A truthy value if the model and serial number apply, otherwise a falsy value. The falsy value is not always a Boolean: it may be '' or undefined when appStr is empty or missing.
isInSerialNums()acType.isInSerialNums(serialNum, serialNums)
This function returns true if the serial number serialNum is in the serial number range specified by serialNums. If serialNums is '-' then all serial numbers are accepted.
serialNumserialNums (optional)A Boolean.
isModel()acType.isModel(modelExp)
acType.isModel(modelExp, modelId)
This function returns true if the model expression modelExp (a RegExp or RegExp string) matches the internal model ID modelId.
This function is used to verify that the model expression extracted from an applicability string matches a specified internal model.
modelExpmodelId (optional)sv.ac_data.value.modelId is used.A Boolean.
isSelectorClass()acType.isSelectorClass(optClass)
This function returns true if the option class has been marked to be presented as a selector by acType.optionUseSelector().
optClassA Boolean that is true if the option class is presented as a selector.
isValidSerialNumber()acType.isValidSerialNumber(modelId, serialNum)
This function returns true if serialNum in valid for the interhal modelId.
modelIdserialNumA Boolean.
models()acType.models()
This function returns an array of all defined internal model IDs.
An array of model ID strings.
modelTitle()acType.modelTitle(modelId)
This function returns the title (info.title) of the internal model ID modelId.
modelIdA string containing the model title.
newName()acType.newName(currentNames)
This function returns a new unique aircraft name that doesn't confilct with any existing name in the currentNames array. It is intended to be used by the Aircraft page when a new aircraft is defined to create a unique name.
acType.newName() returns N if it isn't in currentNames. Otherwise it returns the first of N 2, N 3, ... that isn't.
currentNamesA string containing a unique name.
optionConflicts()acType.optionConflicts(selected)
This function finds the incompatible combinations in a list of selected option IDs. The installation of an aircraft's options asserts on exactly these when the aircraft is set, so a caller holding a stored option list can check it first. Options conflict when they share an option class, either from optClass or from the base ID of a variant ID (e.g., FS510#1 and FS510#2). Repeated IDs and IDs that are not defined options are ignored.
selected (optional)An array of [classId, [optId, ...]] entries, one for each option class that holds more than one of the selected options. It is empty if there are no conflicts.
optionDataConflicts()acType.optionDataConflicts(modelId)
This function finds data conflicts among the options offered on the internal model modelId: an option that one option includes while another option that can be installed alongside it excludes it (incompatibleWith), an option that something both includes and excludes, or an included option that is not offered on the model at all. The installation of options resolves a conflict deterministically (the exclusion wins) but asserts, so the aircraft data self-test runs this for every model. Applicability is judged by model only: two options offered on disjoint serial number ranges count as installable together.
modelIdAn array of conflict message strings. It is empty if there are no conflicts.
optionInfo()acType.optionInfo(optId)
This function returns the info object that option optId was created with (see acType.createOption()). It asserts if the option ID is not defined. It is intended for the option self-tests, which check every option's applicability and installation.
optIdThe option's info object.
optionUseSelector()acType.optionUseSelector(optClass)
acType.optionUseSelector(optClass, title)
This function marks an option class to be presented to the user as a single selector rather than as a checkbox for each of its options, as described in Presenting an option class as a selector. It is normally called from the aircraft data file that defines the class's options.
The selector's choices are built from the class's available options, so the options themselves need no additional properties.
optClasstitle (optional)acType.renderOptionRows() generates for the class. Defaults to the option class ID.renderAvailableDataSources()acType.renderAvailableDataSources(extModelId, serialNum)
If serial number serialNum identifies a valid internal model for the extern model ID extModelId then this function returns ''. Otherwise, the function returns a Template with a table containing the available data sources for the internal models associated with extModelId. The table contains the serial number ranges that apply to each data source.
This function is intended for use by the Aircraft page's render() method to inform users of which data POH data sources are available when the serial number is incorrect.
extModelIdserialNumA Template containing a <Table> component.
renderOptionRows()acType.renderOptionRows(displayable, modelDataSv, selectedOptSv)
This function returns a Template with a <When> component that triggers when either of the state variables modelDataSv or selectedOptSv is changed. modelDataSv.value contains the constructed model data for the current model and serial number. Normally, this mirrors the contents of acData. selectedOptSv.value contains an array of option IDs for the options that are currently installed in modelDataSv.value. When modelDataSv or selectedOptSv changes, the <When> component generates an array of card rows (<Cr> components) representing each option ID in displayable for the model and serial number. Use acType.displayableOptions() to get displayable from modelDataSv.value.options.available. When a checkbox is selected or deselected, the list in selectedOptSv.value is adjusted.
Each row contains a label with the option title and a value with a checkbox that will be checked if the option appears in the list in selectedOptSv.value. Options that are not in the list of selectable options in modelDataSv.value.options.selectable) will appear greyed out, and the checkbox will be disabled.
This function is intended for use by the Aircraft page's render() method to allow users to select and deselect options. The disabled options also make conflicting options visible.
Options belonging to a class marked by acType.optionUseSelector() are not given a checkbox each. They collapse into a single row holding a selector, drawn where the first of them would have appeared. See Presenting an option class as a selector.
The rows are drawn in the order of displayable. Filtering by display group, ordering by info.displayOrder, and leaving out permanent options are done by acType.displayableOptions(), not by this function.
displayableacType.displayableOptions().modelDataSvselectedOptSvA Template containing a <When> component.
renderSourceList()acType.renderSourceList()
This function returns a Template with a <ul> containing a list of all aircraft data sources in the app. This includes all POHs (or Owners Manuals) and Aircraft Flight Manual Supplements.
A Template containing a <ul> list.
restoreAcData()acType.restoreAcData(modelData)
This function makes previously built model data the acData global again, for example after calling acType.setAcData() to temporarily set other aircraft to validate them. Any data loaded into modelData since it was built is kept. Unlike setAcData(), it doesn't rebuild the data.
modelDataacType.setAcData() (or the value of acData).The acData object.
selectOption()acType.selectOption(selectedOptSv, optionId)
This function adds options ID optionId to the array in selectedOptSv.value. This does not rebuild the aircraft data or change acData. acType.setAcData() must eventually be called to rebuild the aircraft data with the new option settings. This function is for conveniently manipulating selectedOptSv.
selectedOptSvoptionIdsetAcData()acType.setAcData(extModelId)
acType.setAcData(extModelId, serialNum)
acType.setAcData(extModelId, serialNum, selectedOptions)
This function builds the current aircraft data according to the external model ID extModelId, the serial number serialNum, and the array of selected options in selectedOptions. The aircraft data is built by copying the full data of the internal model for extModelId and serialNum (the model data that acType.init() already merged over the type-wide data), then overlaying the data of the installed options. If serialNum is not valid for the model, the model's default serial number is used instead. If extModelId has several internal models and serialNum doesn't select one, the one with isDefaultModel set is used, or else the latest. See Selecting an aircraft model.
extModelIdserialNum (optional)selectedOptions (optional)setSelectorOption()acType.setSelectorOption(optClass, optionId)
acType.setSelectorOption(optClass, optionId, options)
This function installs an option of an option class, uninstalling whichever member of the class is installed now. Pass an empty string as optionId to install none of them. This is the operation the selector returned by acType.getSelector() performs when the user chooses an option.
The change is made in one assignment to selectedOptSv, because a member of the class being installed makes its siblings unselectable: acType.selectOption() would reject the new option. As with acType.selectOption(), this does not rebuild the aircraft data; acType.setAcData() must eventually be called.
Choosing the class's default option — the one whose installedOn applies to the model — clears the class rather than selecting the option as well, since that option installs itself.
optClassoptionIdoptions (optional)modelDataSv and selectedOptSv properties described for acType.getSelector().setTypeData()acType.setTypeData(info)
This function sets the type-wide data object to info. The properties in info will be used as a base for all defined aircraft. They may be overridden by either aircraft or option properties.
infounselectOption()acType.unselectOption(selectedOptSv, optionId)
This function removes options ID optionId from the array in selectedOptSv.value. This does not rebuild the aircraft data or change acData. acType.setAcData() must eventually be called to rebuild the aircraft data with the new option settings. This function is for conveniently manipulating selectedOptSv.
selectedOptSvoptionId