registry: RangeController, ModeController, ToggleController with resources, presets and semantics
The three generic controllers are described in full and leave the stub table (62 stubs remain). A declaration
takes an instance name, friendly names from text() and asset(), and the options of the interface: range, unit and
presets for a range; supportedModes and ordered for a mode; semantics() for all three, with actions mapped to
directives and states mapped to a value or a range of values.
Refused at device.add(), each with the endpoint, interface and instance in the message: no instance name or no
friendly name; an instance declared twice; a first friendly name or a phrase used by another capability of the
endpoint; a reserved word, an asset id that is not in the catalog; range.max not above range.min; a preset off the
precision grid or outside the range; fewer than two modes or a mode listed twice; a mapping to a directive the
interface does not have, to a payload that does not fit, to a mode that is not listed, to AdjustMode on modes
that are not ordered; SetEcoOn, SetEcoOff, EcoOn and EcoOff on anything but a toggle.
For 1.x callers: Alexa.RangeController lists rangeValue (1.5.2 sent supported: []); addSupportedModes() announces
a mode given as a string as { value } and notes it, and takes { ordered: false } as a second argument, the default
stays true as 1.5.2 sent it (device.add() defaults to false). Declared the 1.x way, the zoo fan and curtain give
the same JSON as before.
Tests: the zoo blind, whose range, unit and semantics were written by hand into the JSON of 1.5.2, is declared
with device.add() and equals that JSON plus the Alexa capability; five capability objects of Amazon's examples
are reproduced the same way. 27 examples of four pages added. npm test: 108 pass (was 85) in 10.5-11.3 s, also on
Node 18.20.8 and 20.20.2.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
parent
c492ef74d1
commit
2558e21787
80 changed files with 3131 additions and 107 deletions
17
dist/cjs/registry/index.js
vendored
17
dist/cjs/registry/index.js
vendored
|
|
@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
|
|||
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.SchemaError = exports.s = exports.defineInterface = exports.DeclarationError = exports.TemperatureSensor = exports.PowerController = exports.EndpointHealth = exports.BrightnessController = exports.Alexa = exports.registry = void 0;
|
||||
exports.SchemaError = exports.s = exports.defineInterface = exports.DeclarationError = exports.SemanticsBuilder = exports.semantics = exports.text = exports.asset = exports.ToggleController = exports.TemperatureSensor = exports.RangeController = exports.PowerController = exports.ModeController = exports.EndpointHealth = exports.BrightnessController = exports.Alexa = exports.registry = void 0;
|
||||
// The interfaces the library knows, by namespace.
|
||||
const Alexa_js_1 = require("./interfaces/Alexa.js");
|
||||
Object.defineProperty(exports, "Alexa", { enumerable: true, get: function () { return Alexa_js_1.Alexa; } });
|
||||
|
|
@ -22,18 +22,27 @@ const BrightnessController_js_1 = require("./interfaces/BrightnessController.js"
|
|||
Object.defineProperty(exports, "BrightnessController", { enumerable: true, get: function () { return BrightnessController_js_1.BrightnessController; } });
|
||||
const EndpointHealth_js_1 = require("./interfaces/EndpointHealth.js");
|
||||
Object.defineProperty(exports, "EndpointHealth", { enumerable: true, get: function () { return EndpointHealth_js_1.EndpointHealth; } });
|
||||
const ModeController_js_1 = require("./interfaces/ModeController.js");
|
||||
Object.defineProperty(exports, "ModeController", { enumerable: true, get: function () { return ModeController_js_1.ModeController; } });
|
||||
const PowerController_js_1 = require("./interfaces/PowerController.js");
|
||||
Object.defineProperty(exports, "PowerController", { enumerable: true, get: function () { return PowerController_js_1.PowerController; } });
|
||||
const RangeController_js_1 = require("./interfaces/RangeController.js");
|
||||
Object.defineProperty(exports, "RangeController", { enumerable: true, get: function () { return RangeController_js_1.RangeController; } });
|
||||
const TemperatureSensor_js_1 = require("./interfaces/TemperatureSensor.js");
|
||||
Object.defineProperty(exports, "TemperatureSensor", { enumerable: true, get: function () { return TemperatureSensor_js_1.TemperatureSensor; } });
|
||||
const ToggleController_js_1 = require("./interfaces/ToggleController.js");
|
||||
Object.defineProperty(exports, "ToggleController", { enumerable: true, get: function () { return ToggleController_js_1.ToggleController; } });
|
||||
const stubs_js_1 = require("./interfaces/stubs.js");
|
||||
const types_js_1 = require("./types.js");
|
||||
const described = [
|
||||
Alexa_js_1.Alexa,
|
||||
BrightnessController_js_1.BrightnessController,
|
||||
EndpointHealth_js_1.EndpointHealth,
|
||||
ModeController_js_1.ModeController,
|
||||
PowerController_js_1.PowerController,
|
||||
RangeController_js_1.RangeController,
|
||||
TemperatureSensor_js_1.TemperatureSensor,
|
||||
ToggleController_js_1.ToggleController,
|
||||
];
|
||||
const descriptors = new Map();
|
||||
for (const descriptor of [...described, ...stubs_js_1.STUBS]) {
|
||||
|
|
@ -59,6 +68,12 @@ exports.registry = {
|
|||
return [...descriptors.values()].sort((a, b) => (a.namespace < b.namespace ? -1 : 1));
|
||||
},
|
||||
};
|
||||
var resources_js_1 = require("./resources.js");
|
||||
Object.defineProperty(exports, "asset", { enumerable: true, get: function () { return resources_js_1.asset; } });
|
||||
Object.defineProperty(exports, "text", { enumerable: true, get: function () { return resources_js_1.text; } });
|
||||
var semantics_js_1 = require("./semantics.js");
|
||||
Object.defineProperty(exports, "semantics", { enumerable: true, get: function () { return semantics_js_1.semantics; } });
|
||||
Object.defineProperty(exports, "SemanticsBuilder", { enumerable: true, get: function () { return semantics_js_1.SemanticsBuilder; } });
|
||||
var types_js_2 = require("./types.js");
|
||||
Object.defineProperty(exports, "DeclarationError", { enumerable: true, get: function () { return types_js_2.DeclarationError; } });
|
||||
Object.defineProperty(exports, "defineInterface", { enumerable: true, get: function () { return types_js_2.defineInterface; } });
|
||||
|
|
|
|||
87
dist/cjs/registry/interfaces/ModeController.js
vendored
Normal file
87
dist/cjs/registry/interfaces/ModeController.js
vendored
Normal file
|
|
@ -0,0 +1,87 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.ModeController = void 0;
|
||||
const resources_js_1 = require("../resources.js");
|
||||
const schema_js_1 = require("../schema.js");
|
||||
const semantics_js_1 = require("../semantics.js");
|
||||
const types_js_1 = require("../types.js");
|
||||
const directives = {
|
||||
SetMode: { name: "SetMode", payload: schema_js_1.s.object({ mode: schema_js_1.s.string({ min: 1 }) }) },
|
||||
AdjustMode: {
|
||||
name: "AdjustMode",
|
||||
payload: schema_js_1.s.object({ modeDelta: schema_js_1.s.optional(schema_js_1.s.number({ integer: true })) }),
|
||||
// alexa-modecontroller.html, "Capabilities object": "Modes that have an order support the AdjustMode directive."
|
||||
when: ({ options }) => options.ordered === true,
|
||||
note: "modeDelta is the number of modes to move by, 1 when it is left out",
|
||||
},
|
||||
};
|
||||
// A mode is declared as { value, friendlyNames }. The object of discovery and of 1.x, { value, modeResources:
|
||||
// { friendlyNames } }, is taken as well.
|
||||
const eitherForm = schema_js_1.s.object({
|
||||
value: schema_js_1.s.string({ min: 1 }),
|
||||
friendlyNames: schema_js_1.s.optional(schema_js_1.s.unknown()),
|
||||
modeResources: schema_js_1.s.optional(schema_js_1.s.object({ friendlyNames: schema_js_1.s.unknown() })),
|
||||
}, { unknownKeys: "reject" });
|
||||
const mode = {
|
||||
expects: "a mode { value, friendlyNames }",
|
||||
parse(input, path = "") {
|
||||
if (typeof input !== "object" || input === null)
|
||||
throw (0, schema_js_1.mismatch)(path, mode.expects, input);
|
||||
const { value, friendlyNames, modeResources } = eitherForm.parse(input, path);
|
||||
const named = friendlyNames === undefined && modeResources ? "modeResources.friendlyNames" : "friendlyNames";
|
||||
return { value, friendlyNames: resources_js_1.labels.parse(friendlyNames ?? modeResources?.friendlyNames, (0, schema_js_1.at)(path, named)) };
|
||||
},
|
||||
};
|
||||
/**
|
||||
* One of a list of values, under an instance name: the wash cycle of a washer, the position of a garage door. Amazon
|
||||
* certifies a garage door only with this interface and the display category GARAGE_DOOR.
|
||||
*/
|
||||
exports.ModeController = (0, types_js_1.defineInterface)({
|
||||
namespace: "Alexa.ModeController",
|
||||
version: "3",
|
||||
doc: "https://developer.amazon.com/docs/alexaplus/device-apis/alexa-modecontroller.html",
|
||||
kind: "controller",
|
||||
tier: 1,
|
||||
instanced: true,
|
||||
properties: {
|
||||
mode: { name: "mode", value: schema_js_1.s.nullable(schema_js_1.s.string({ min: 1 })), note: "null when no mode is set, as when the device is off" },
|
||||
},
|
||||
directives,
|
||||
options: schema_js_1.s.object({
|
||||
/** At least two. When the modes have an order, in increasing order. */
|
||||
supportedModes: schema_js_1.s.array(mode, { min: 2 }),
|
||||
/** The modes have an order, cold to hot, and the user can say "increase": Alexa sends AdjustMode. Default: false. */
|
||||
ordered: schema_js_1.s.optional(schema_js_1.s.boolean()),
|
||||
semantics: schema_js_1.s.optional((0, semantics_js_1.semanticsOf)({ directives, stateValue: schema_js_1.s.string({ min: 1 }) })),
|
||||
}, { unknownKeys: "reject" }),
|
||||
// A capability declared the 1.x way may be without modes, or have modes without names
|
||||
discovery({ options: { supportedModes = [], ordered = false } }) {
|
||||
if (supportedModes.length === 0)
|
||||
return {};
|
||||
const modes = supportedModes.map(({ value, friendlyNames = [] }) => (friendlyNames.length > 0 ? { value, modeResources: { friendlyNames } } : { value }));
|
||||
return { configuration: { ordered, supportedModes: modes } };
|
||||
},
|
||||
validate(capability) {
|
||||
const { supportedModes, ordered = false, semantics } = capability.options;
|
||||
const values = supportedModes.map(({ value }) => value);
|
||||
const twice = values.find((value, i) => values.indexOf(value) !== i);
|
||||
if (twice !== undefined)
|
||||
throw new types_js_1.DeclarationError(capability, `the mode ${twice} is listed twice`);
|
||||
const isMode = (value) => values.includes(value);
|
||||
for (const { directive } of semantics?.actionMappings ?? []) {
|
||||
if (directive.name === "AdjustMode" && !ordered) {
|
||||
throw new types_js_1.DeclarationError(capability, "an action is mapped to AdjustMode, which needs ordered: true");
|
||||
}
|
||||
if (directive.name === "SetMode" && !isMode(directive.payload?.mode)) {
|
||||
throw new types_js_1.DeclarationError(capability, `an action is mapped to SetMode ${directive.payload?.mode}, the modes are ${values.join(", ")}`);
|
||||
}
|
||||
}
|
||||
for (const mapping of semantics?.stateMappings ?? []) {
|
||||
if (mapping["@type"] === "StatesToValue" && !isMode(mapping.value)) {
|
||||
throw new types_js_1.DeclarationError(capability, `a state is mapped to ${mapping.value}, the modes are ${values.join(", ")}`);
|
||||
}
|
||||
}
|
||||
},
|
||||
errorNamespace: "Alexa.Safety",
|
||||
errorTypes: ["OBSTACLE_DETECTED", "SAFETY_BEAM_BREACHED"],
|
||||
});
|
||||
76
dist/cjs/registry/interfaces/RangeController.js
vendored
Normal file
76
dist/cjs/registry/interfaces/RangeController.js
vendored
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.RangeController = void 0;
|
||||
const catalog_js_1 = require("../catalog.js");
|
||||
const resources_js_1 = require("../resources.js");
|
||||
const schema_js_1 = require("../schema.js");
|
||||
const semantics_js_1 = require("../semantics.js");
|
||||
const types_js_1 = require("../types.js");
|
||||
const directives = {
|
||||
SetRangeValue: { name: "SetRangeValue", payload: schema_js_1.s.object({ rangeValue: schema_js_1.s.number() }) },
|
||||
AdjustRangeValue: {
|
||||
name: "AdjustRangeValue",
|
||||
payload: schema_js_1.s.object({ rangeValueDelta: schema_js_1.s.number(), rangeValueDeltaDefault: schema_js_1.s.boolean() }),
|
||||
note: "rangeValueDeltaDefault is true when the user named no amount; rangeValueDelta is then the precision",
|
||||
},
|
||||
};
|
||||
// 0.1 + 0.2 is not 0.3: a value is on the grid when it is within a millionth of a step of it
|
||||
function onGrid(value, origin, step) {
|
||||
const steps = (value - origin) / step;
|
||||
return Math.abs(steps - Math.round(steps)) < 1e-6;
|
||||
}
|
||||
/**
|
||||
* A number in a range, under an instance name: the position of a blind, the speed of a fan. With nonControllable it
|
||||
* is a reading the user can ask for, like an air quality index.
|
||||
*/
|
||||
exports.RangeController = (0, types_js_1.defineInterface)({
|
||||
namespace: "Alexa.RangeController",
|
||||
version: "3",
|
||||
doc: "https://developer.amazon.com/docs/alexaplus/device-apis/alexa-rangecontroller.html",
|
||||
kind: "controller",
|
||||
tier: 1,
|
||||
instanced: true,
|
||||
properties: {
|
||||
rangeValue: { name: "rangeValue", value: schema_js_1.s.number() },
|
||||
},
|
||||
directives,
|
||||
options: schema_js_1.s.object({
|
||||
/** precision is the step of the range and what "turn up the fan speed" changes it by. */
|
||||
range: schema_js_1.s.object({ min: schema_js_1.s.number(), max: schema_js_1.s.number(), precision: schema_js_1.s.number({ gt: 0 }) }, { unknownKeys: "reject" }),
|
||||
unit: schema_js_1.s.optional(schema_js_1.s.oneOf(catalog_js_1.UNITS_OF_MEASURE, "a unit of measure like Alexa.Unit.Percent")),
|
||||
/** Names for values: "set the fan speed to maximum". */
|
||||
presets: schema_js_1.s.optional(schema_js_1.s.array(schema_js_1.s.object({ value: schema_js_1.s.number(), friendlyNames: resources_js_1.labels }, { unknownKeys: "reject" }))),
|
||||
semantics: schema_js_1.s.optional((0, semantics_js_1.semanticsOf)({ directives, stateValue: schema_js_1.s.number(), ranges: true })),
|
||||
}, { unknownKeys: "reject" }),
|
||||
// A capability declared the 1.x way may be without a range; check() says so, discovery lists what there is
|
||||
discovery({ options: { range, unit, presets } }) {
|
||||
const configuration = {
|
||||
...(range && { supportedRange: { minimumValue: range.min, maximumValue: range.max, precision: range.precision } }),
|
||||
...(unit && { unitOfMeasure: unit }),
|
||||
...(presets && { presets: presets.map(({ value, friendlyNames }) => ({ rangeValue: value, presetResources: { friendlyNames } })) }),
|
||||
};
|
||||
return Object.keys(configuration).length > 0 ? { configuration } : {};
|
||||
},
|
||||
validate(capability) {
|
||||
const { range: { min, max, precision }, presets = [], semantics } = capability.options;
|
||||
const inRange = (value) => value >= min && value <= max;
|
||||
if (max <= min)
|
||||
throw new types_js_1.DeclarationError(capability, `range.max ${max} is not above range.min ${min}`);
|
||||
for (const { value } of presets) {
|
||||
// alexa-rangecontroller.html, "Preset object": "minimum range value + (n x precision) where n is an integer"
|
||||
if (!inRange(value) || !onGrid(value, min, precision)) {
|
||||
throw new types_js_1.DeclarationError(capability, `the preset ${value} is not ${min} + n x ${precision}, up to ${max}`);
|
||||
}
|
||||
}
|
||||
for (const { directive } of semantics?.actionMappings ?? []) {
|
||||
const { rangeValue } = directive.payload ?? {};
|
||||
if (directive.name === "SetRangeValue" && !inRange(rangeValue)) {
|
||||
throw new types_js_1.DeclarationError(capability, `an action is mapped to SetRangeValue ${rangeValue}, the range is ${min} to ${max}`);
|
||||
}
|
||||
}
|
||||
},
|
||||
// alexa-rangecontroller.html, "SetRangeValue directive error handling": "If your error is safety related, respond
|
||||
// with an Alexa.Safety.ErrorResponse"
|
||||
errorNamespace: "Alexa.Safety",
|
||||
errorTypes: ["OBSTACLE_DETECTED", "SAFETY_BEAM_BREACHED"],
|
||||
});
|
||||
31
dist/cjs/registry/interfaces/ToggleController.js
vendored
Normal file
31
dist/cjs/registry/interfaces/ToggleController.js
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.ToggleController = void 0;
|
||||
const schema_js_1 = require("../schema.js");
|
||||
const semantics_js_1 = require("../semantics.js");
|
||||
const types_js_1 = require("../types.js");
|
||||
const directives = {
|
||||
TurnOn: { name: "TurnOn", payload: schema_js_1.s.object({}) },
|
||||
TurnOff: { name: "TurnOff", payload: schema_js_1.s.object({}) },
|
||||
};
|
||||
/**
|
||||
* Something that is on or off, under an instance name: the oscillation of a fan, the light of an oven. The one
|
||||
* generic controller that Alexa hunches work with (SetEcoOn, SetEcoOff, EcoOn, EcoOff).
|
||||
*/
|
||||
exports.ToggleController = (0, types_js_1.defineInterface)({
|
||||
namespace: "Alexa.ToggleController",
|
||||
version: "3",
|
||||
doc: "https://developer.amazon.com/docs/alexaplus/device-apis/alexa-togglecontroller.html",
|
||||
kind: "controller",
|
||||
tier: 1,
|
||||
instanced: true,
|
||||
properties: {
|
||||
toggleState: { name: "toggleState", value: schema_js_1.s.enum("ON", "OFF") },
|
||||
},
|
||||
directives,
|
||||
options: schema_js_1.s.object({
|
||||
semantics: schema_js_1.s.optional((0, semantics_js_1.semanticsOf)({ directives, stateValue: schema_js_1.s.enum("ON", "OFF"), hunches: true })),
|
||||
}, { unknownKeys: "reject" }),
|
||||
errorNamespace: "Alexa.Safety",
|
||||
errorTypes: ["OBSTACLE_DETECTED", "SAFETY_BEAM_BREACHED"],
|
||||
});
|
||||
8
dist/cjs/registry/interfaces/stubs.js
vendored
8
dist/cjs/registry/interfaces/stubs.js
vendored
|
|
@ -48,7 +48,6 @@ const TABLE = [
|
|||
["Alexa.Media.PlayQueue", "1", [], "alexa-media-playqueue.html"],
|
||||
["Alexa.Media.Playback", "1", [], "alexa-media-playback.html"],
|
||||
["Alexa.Media.Search", "1", [], "alexa-media-search.html"],
|
||||
["Alexa.ModeController", "3", ["mode"], "alexa-modecontroller.html"],
|
||||
["Alexa.MotionSensor", "3", [], "alexa-motionsensor.html"],
|
||||
["Alexa.PercentageController", "3", [], "alexa-percentagecontroller.html"],
|
||||
["Alexa.PlaybackController", "3", [], "alexa-playbackcontroller.html"],
|
||||
|
|
@ -56,7 +55,6 @@ const TABLE = [
|
|||
["Alexa.PowerLevelController", "3", [], "alexa-powerlevelcontroller.html"],
|
||||
["Alexa.ProactiveNotificationSource", "1", [], "alexa-proactivenotificationsource.html"],
|
||||
["Alexa.RTCSessionController", "1", [], "alexa-rtcsessioncontroller.html"],
|
||||
["Alexa.RangeController", "3", [], "alexa-rangecontroller.html"],
|
||||
["Alexa.RecordController", "3", [], "alexa-recordcontroller.html"],
|
||||
["Alexa.RemoteVideoPlayer", "1", [], "alexa-remotevideoplayer.html"],
|
||||
["Alexa.SceneController", "3", [], "alexa-scenecontroller.html"],
|
||||
|
|
@ -74,13 +72,12 @@ const TABLE = [
|
|||
["Alexa.ThermostatController.Schedule", "1", [], "alexa-thermostatcontroller-schedule.html"],
|
||||
// "UNKNOWN" in 1.5.2 as well; the page is titled "Interface 3"
|
||||
["Alexa.TimeHoldController", "3", [], "alexa-timeholdcontroller.html"],
|
||||
["Alexa.ToggleController", "3", ["toggleState"], "alexa-togglecontroller.html"],
|
||||
["Alexa.UIController", "1", [], "alexa-uicontroller.html"],
|
||||
["Alexa.UserPreference", "1", [], "alexa-userpreference.html"],
|
||||
["Alexa.VideoRecorder", "1", [], "alexa-videorecorder.html"],
|
||||
["Alexa.WakeOnLANController", "1", [], "alexa-wakeonlancontroller.html"],
|
||||
];
|
||||
// What 1.5.2 added to the capability object of three of them
|
||||
// What 1.5.2 added to the capability object of two of them
|
||||
const EXTRAS = {
|
||||
// No properties object; supportsDeactivation and proactivelyReported on the capability itself
|
||||
"Alexa.SceneController": ({ proactivelyReported }) => ({
|
||||
|
|
@ -90,9 +87,6 @@ const EXTRAS = {
|
|||
"Alexa.ThermostatController": () => ({
|
||||
configuration: { supportedModes: ["HEAT", "COOL", "AUTO", "OFF"], supportsScheduling: false },
|
||||
}),
|
||||
"Alexa.ModeController": ({ options }) => (options.supportedModes?.length > 0
|
||||
? { configuration: { ordered: true, supportedModes: options.supportedModes } }
|
||||
: {}),
|
||||
};
|
||||
function kindOf(namespace) {
|
||||
if (namespace.endsWith("Sensor"))
|
||||
|
|
|
|||
2
dist/cjs/registry/resources.js
vendored
2
dist/cjs/registry/resources.js
vendored
|
|
@ -27,6 +27,8 @@ const reserved = catalog_js_1.RESERVED_WORDS;
|
|||
exports.label = {
|
||||
expects: "a friendly name, from text() or asset()",
|
||||
parse(input, path = "") {
|
||||
if (typeof input !== "object" || input === null)
|
||||
throw (0, schema_js_1.mismatch)(path, exports.label.expects, input);
|
||||
const { "@type": type, value } = typed.parse(input, path);
|
||||
if (type === "asset")
|
||||
return { "@type": type, value: assetValue.parse(value, (0, schema_js_1.at)(path, "value")) };
|
||||
|
|
|
|||
112
dist/cjs/registry/semantics.js
vendored
Normal file
112
dist/cjs/registry/semantics.js
vendored
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.SemanticsBuilder = void 0;
|
||||
exports.semantics = semantics;
|
||||
exports.semanticsOf = semanticsOf;
|
||||
// Semantics of a generic controller: the phrases "open", "close", "raise", "lower" mapped to directives, and states
|
||||
// like "open" and "closed" mapped to values of the property (alexa-discovery-objects.html, "Semantics object").
|
||||
const catalog_js_1 = require("./catalog.js");
|
||||
const schema_js_1 = require("./schema.js");
|
||||
const listed = (given) => (Array.isArray(given) ? [...given] : [given]);
|
||||
const withPrefix = (prefix, name) => (name.startsWith(prefix) ? name : `${prefix}${name}`);
|
||||
/**
|
||||
* Collects the mappings of one capability:
|
||||
*
|
||||
* semantics()
|
||||
* .action("Close", "SetRangeValue", { rangeValue: 0 })
|
||||
* .action(["Open", "Raise"], "SetRangeValue", { rangeValue: 100 })
|
||||
* .state("Closed", 0)
|
||||
* .stateRange("Open", 1, 100)
|
||||
*
|
||||
* What is collected is checked when the capability is declared, against the directives and the property of its
|
||||
* interface.
|
||||
*/
|
||||
class SemanticsBuilder {
|
||||
constructor() {
|
||||
this.actionMappings = [];
|
||||
this.stateMappings = [];
|
||||
}
|
||||
/** The phrases send the directive. payload is its payload; leave it out for a directive that has none. */
|
||||
action(actions, directive, payload) {
|
||||
this.actionMappings.push({
|
||||
"@type": "ActionsToDirective",
|
||||
actions: listed(actions).map((name) => withPrefix("Alexa.Actions.", name)),
|
||||
directive: payload === undefined ? { name: directive } : { name: directive, payload },
|
||||
});
|
||||
return this;
|
||||
}
|
||||
/** The property at this value is in these states: "is the garage door open?" */
|
||||
state(states, value) {
|
||||
this.stateMappings.push({ "@type": "StatesToValue", states: listed(states).map((name) => withPrefix("Alexa.States.", name)), value });
|
||||
return this;
|
||||
}
|
||||
/** The property between the two values, both included, is in these states. For an interface with a numeric property. */
|
||||
stateRange(states, minimumValue, maximumValue) {
|
||||
this.stateMappings.push({
|
||||
"@type": "StatesToRange",
|
||||
states: listed(states).map((name) => withPrefix("Alexa.States.", name)),
|
||||
range: { minimumValue, maximumValue },
|
||||
});
|
||||
return this;
|
||||
}
|
||||
}
|
||||
exports.SemanticsBuilder = SemanticsBuilder;
|
||||
function semantics() {
|
||||
return new SemanticsBuilder();
|
||||
}
|
||||
const isHunch = (id) => /\.(SetEcoOn|SetEcoOff|EcoOn|EcoOff)$/.test(id);
|
||||
/** The schema of the semantics option of one interface. It takes a semantics() builder or the object as discovery has it. */
|
||||
function semanticsOf({ directives, stateValue, ranges = false, hunches = false }) {
|
||||
const allowed = (ids, what) => {
|
||||
const choice = ids.filter((id) => hunches || !isHunch(id));
|
||||
return schema_js_1.s.array(schema_js_1.s.oneOf(choice, `${what}: ${choice.map((id) => id.split(".")[2]).join(", ")}`), { min: 1 });
|
||||
};
|
||||
const names = Object.keys(directives);
|
||||
const lists = schema_js_1.s.object({ actionMappings: schema_js_1.s.optional(schema_js_1.s.array(schema_js_1.s.unknown())), stateMappings: schema_js_1.s.optional(schema_js_1.s.array(schema_js_1.s.unknown())) });
|
||||
const action = schema_js_1.s.object({
|
||||
"@type": schema_js_1.s.literal("ActionsToDirective"),
|
||||
actions: allowed(catalog_js_1.ACTIONS, "a phrase of Alexa.Actions"),
|
||||
directive: schema_js_1.s.object({ name: schema_js_1.s.oneOf(names, `a directive of the interface: ${names.join(", ")}`) }),
|
||||
});
|
||||
const state = schema_js_1.s.object({
|
||||
"@type": ranges ? schema_js_1.s.enum("StatesToValue", "StatesToRange") : schema_js_1.s.enum("StatesToValue"),
|
||||
states: allowed(catalog_js_1.STATES, "a state of Alexa.States"),
|
||||
});
|
||||
const range = schema_js_1.s.object({ minimumValue: schema_js_1.s.number(), maximumValue: schema_js_1.s.number() }, { unknownKeys: "reject" });
|
||||
function actionMapping(input, path) {
|
||||
const mapping = action.parse(input, path);
|
||||
const { name, payload } = mapping.directive;
|
||||
// Checked as the directive will arrive; a mapping without a payload stays without one in discovery
|
||||
const checked = directives[name].payload.parse(payload ?? {}, (0, schema_js_1.at)(path, "directive.payload"));
|
||||
return { "@type": mapping["@type"], actions: mapping.actions, directive: payload === undefined ? { name } : { name, payload: checked } };
|
||||
}
|
||||
function stateMapping(input, path) {
|
||||
const mapping = state.parse(input, path);
|
||||
if (mapping["@type"] === "StatesToValue") {
|
||||
return { "@type": mapping["@type"], states: mapping.states, value: stateValue.parse(mapping.value, (0, schema_js_1.at)(path, "value")) };
|
||||
}
|
||||
const { minimumValue, maximumValue } = range.parse(mapping.range, (0, schema_js_1.at)(path, "range"));
|
||||
if (minimumValue > maximumValue)
|
||||
throw new schema_js_1.SchemaError((0, schema_js_1.at)(path, "range"), `the minimumValue ${minimumValue} is above the maximumValue ${maximumValue}`);
|
||||
return { "@type": mapping["@type"], states: mapping.states, range: { minimumValue, maximumValue } };
|
||||
}
|
||||
const expects = "semantics() with at least one action or state";
|
||||
return {
|
||||
expects,
|
||||
parse(input, path = "") {
|
||||
if (typeof input !== "object" || input === null)
|
||||
throw (0, schema_js_1.mismatch)(path, expects, input);
|
||||
const { actionMappings = [], stateMappings = [] } = lists.parse(input, path);
|
||||
if (actionMappings.length + stateMappings.length === 0)
|
||||
throw (0, schema_js_1.mismatch)(path, expects, {});
|
||||
const parsed = {};
|
||||
if (actionMappings.length > 0) {
|
||||
parsed.actionMappings = actionMappings.map((mapping, i) => actionMapping(mapping, `${(0, schema_js_1.at)(path, "actionMappings")}[${i}]`));
|
||||
}
|
||||
if (stateMappings.length > 0) {
|
||||
parsed.stateMappings = stateMappings.map((mapping, i) => stateMapping(mapping, `${(0, schema_js_1.at)(path, "stateMappings")}[${i}]`));
|
||||
}
|
||||
return parsed;
|
||||
},
|
||||
};
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue