David
feff828ec1
src/dispatcher.ts routes a directive to capability.on(name | "*"), device.onDirective() or device.onReportState(), with the payload checked by the descriptor of the interface. The DirectiveContext answers with respond/report/defer/error; respond() and report() start from device.state(). A handler or 1.x listener that throws or rejects is answered with INTERNAL_ERROR (an AlexaError with itself) and reported through "error", never as an unhandled rejection. Undeclared interface, unknown directive, AdjustMode on an unordered mode and a missing handler get INVALID_DIRECTIVE, a bad payload INVALID_VALUE; a device with an "Event" or "ReportState" listener keeps the answer to itself. Every answer passes the dispatcher: the first one per correlationToken is published, a second is refused. No answer within answerWithinMs (6500, 0 = off, unref'd timer) sends INTERNAL_ERROR and emits "unanswered". A messageId that arrived in the last 60 s is dropped. New: "unknownEndpoint", options answerUnknownEndpoints, publisher, timers, and bridge.receive() to run a bridge without a broker. 168 tests pass (18 new). Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
84 lines
4 KiB
JavaScript
84 lines
4 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.Capability = exports.commonOptions = void 0;
|
|
const schema_js_1 = require("../registry/schema.js");
|
|
const types_js_1 = require("../registry/types.js");
|
|
/** The same as a schema. The friendly names are checked with the instance, by the rules of the interface. */
|
|
exports.commonOptions = schema_js_1.s.object({
|
|
instance: schema_js_1.s.optional(schema_js_1.s.string()),
|
|
friendlyNames: schema_js_1.s.optional(schema_js_1.s.array(schema_js_1.s.unknown())),
|
|
retrievable: schema_js_1.s.optional(schema_js_1.s.boolean()),
|
|
proactivelyReported: schema_js_1.s.optional(schema_js_1.s.boolean()),
|
|
nonControllable: schema_js_1.s.optional(schema_js_1.s.boolean()),
|
|
});
|
|
/** One interface as an endpoint declares it: the descriptor, and what the declaration says about this endpoint. */
|
|
class Capability {
|
|
constructor(descriptor, declared) {
|
|
this.descriptor = descriptor;
|
|
/** The endpoint the capability is declared on; the device sets it. */
|
|
this.endpointId = "";
|
|
/** What the bridge logs about the declaration, once, when it answers a discovery. */
|
|
this.notes = [];
|
|
this.handlers = new Map();
|
|
this.instance = declared.instance ?? "";
|
|
this.friendlyNames = declared.friendlyNames ?? [];
|
|
this.retrievable = declared.retrievable ?? true;
|
|
this.proactivelyReported = declared.proactivelyReported ?? false;
|
|
this.nonControllable = declared.nonControllable;
|
|
this.options = declared.options;
|
|
}
|
|
get namespace() {
|
|
return this.descriptor.namespace;
|
|
}
|
|
on(name, handler) {
|
|
const names = Object.keys(this.descriptor.directives);
|
|
// An interface the library only names (tier 3) describes no directive: any name is taken
|
|
if (name !== "*" && this.descriptor.tier !== 3 && !names.includes(name)) {
|
|
throw new types_js_1.DeclarationError(this, `${name} is not a directive of the interface, which has ${names.join(", ") || "none"}`);
|
|
}
|
|
if (typeof handler !== "function")
|
|
throw new types_js_1.DeclarationError(this, `the handler of ${name} is a function`);
|
|
this.handlers.set(name, handler);
|
|
return this;
|
|
}
|
|
/** The handler on(name) registered, or the one of "*". */
|
|
handlerFor(name) {
|
|
return this.handlers.get(name) ?? this.handlers.get("*");
|
|
}
|
|
/** Mappings of "open", "close", "raise", "lower" and of states, when the declaration has any. */
|
|
get semantics() {
|
|
const { semantics } = this.options;
|
|
const mapped = (semantics?.actionMappings?.length ?? 0) + (semantics?.stateMappings?.length ?? 0);
|
|
return mapped > 0 ? semantics : undefined;
|
|
}
|
|
/** The capability object for discovery, its fields in the order of the example on alexa-discovery-objects.html. */
|
|
toJSON() {
|
|
const { descriptor, semantics } = this;
|
|
const extras = descriptor.discovery ? descriptor.discovery(this) : {};
|
|
const json = {
|
|
type: "AlexaInterface",
|
|
interface: descriptor.namespace,
|
|
...(this.instance ? { instance: this.instance } : {}),
|
|
version: descriptor.version,
|
|
};
|
|
if (extras.properties !== false) {
|
|
json.properties = {
|
|
supported: Object.keys(descriptor.properties).map((name) => ({ name })),
|
|
proactivelyReported: this.proactivelyReported,
|
|
retrievable: this.retrievable,
|
|
};
|
|
if (this.nonControllable !== undefined)
|
|
json.properties.nonControllable = this.nonControllable;
|
|
}
|
|
if (this.friendlyNames.length > 0)
|
|
json.capabilityResources = { friendlyNames: this.friendlyNames };
|
|
if (extras.configuration)
|
|
json.configuration = extras.configuration;
|
|
if (extras.configurations)
|
|
json.configurations = extras.configurations;
|
|
if (semantics)
|
|
json.semantics = semantics;
|
|
return { ...json, ...extras.topLevel };
|
|
}
|
|
}
|
|
exports.Capability = Capability;
|