David
b083b23ab0
The message read "the handler of TurnOn is a function", which states the
opposite of what went wrong. It is now
on("TurnOff") got undefined as the handler: pass a function that takes
the context of the directive
under the endpoint and the interface, as every DeclarationError.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
81 lines
3.8 KiB
JavaScript
81 lines
3.8 KiB
JavaScript
import { s } from "../registry/schema.js";
|
|
import { DeclarationError } from "../registry/types.js";
|
|
/** The same as a schema. The friendly names are checked with the instance, by the rules of the interface. */
|
|
export const commonOptions = s.object({
|
|
instance: s.optional(s.string()),
|
|
friendlyNames: s.optional(s.array(s.unknown())),
|
|
retrievable: s.optional(s.boolean()),
|
|
proactivelyReported: s.optional(s.boolean()),
|
|
nonControllable: s.optional(s.boolean()),
|
|
});
|
|
/** One interface as an endpoint declares it: the descriptor, and what the declaration says about this endpoint. */
|
|
export 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 DeclarationError(this, `${name} is not a directive of the interface, which has ${names.join(", ") || "none"}`);
|
|
}
|
|
if (typeof handler !== "function") {
|
|
throw new DeclarationError(this, `on("${name}") got ${handler === null ? "null" : typeof handler} as the handler: pass a function that takes the context of the directive`);
|
|
}
|
|
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: (extras.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 };
|
|
}
|
|
}
|