@smarthome.exchange/integrations 0.1.0 → 1.0.0

package/dist_ts/integrations/wled/wled.classes.subscription.js

@@ -0,0 +1,116 @@
+import * as plugins from '../../plugins.js';
+import { DeviceCommunicationError } from '../../core/errors.js';
+import { parseWledSnapshot } from './wled.validation.js';
+export class WledSubscription {
+    options;
+    socket;
+    starting;
+    resolveStart;
+    rejectStart;
+    closing;
+    resolveClose;
+    deadline;
+    stopping = false;
+    closed = false;
+    healthy = false;
+    constructor(options) {
+        this.options = options;
+    }
+    get isHealthy() { return this.healthy && !this.stopping; }
+    get isClosed() { return this.closed; }
+    get isStopping() { return this.stopping; }
+    start() {
+        if (this.starting)
+            return this.starting;
+        if (this.stopping || this.options.signal.aborted)
+            return Promise.reject(new DOMException('WLED subscription cancelled.', 'AbortError'));
+        this.starting = new Promise((resolveArg, rejectArg) => { this.resolveStart = resolveArg; this.rejectStart = rejectArg; });
+        this.closing = new Promise((resolveArg) => { this.resolveClose = resolveArg; });
+        this.options.signal.addEventListener('abort', this.handleAbort, { once: true });
+        this.deadline = setTimeout(() => this.fail(new DeviceCommunicationError('WLED websocket initial state timed out.')), this.options.timeoutMs);
+        try {
+            this.socket = new plugins.ws.WebSocket(this.options.url, { handshakeTimeout: this.options.timeoutMs, followRedirects: false, perMessageDeflate: false, maxPayload: 1024 * 1024 });
+            this.socket.on('message', this.handleMessage);
+            this.socket.on('error', this.handleError);
+            this.socket.on('close', this.handleClose);
+        }
+        catch {
+            this.fail(new DeviceCommunicationError('WLED websocket connection failed.'));
+            this.finishClose();
+        }
+        return this.starting;
+    }
+    async stop() {
+        this.stopping = true;
+        this.setHealthy(false);
+        clearTimeout(this.deadline);
+        this.rejectStart?.(new DOMException('WLED subscription cancelled.', 'AbortError'));
+        this.rejectStart = undefined;
+        this.resolveStart = undefined;
+        if (!this.socket || this.closed) {
+            this.finishClose();
+            return;
+        }
+        // This receive-only socket owns no outstanding command acknowledgement to preserve.
+        this.socket.terminate();
+        await this.closing;
+    }
+    handleMessage = (dataArg, binaryArg) => {
+        if (this.stopping)
+            return;
+        try {
+            if (binaryArg)
+                throw new DeviceCommunicationError('WLED returned an unexpected binary websocket message.');
+            const data = Array.isArray(dataArg) ? Buffer.concat(dataArg) : dataArg instanceof ArrayBuffer ? Buffer.from(new Uint8Array(dataArg)) : dataArg;
+            const value = JSON.parse(data.toString('utf8'));
+            const snapshot = parseWledSnapshot(value, this.options.mac);
+            this.options.onSnapshot(snapshot);
+            clearTimeout(this.deadline);
+            this.setHealthy(true);
+            this.resolveStart?.();
+            this.resolveStart = undefined;
+            this.rejectStart = undefined;
+        }
+        catch (errorArg) {
+            this.fail(errorArg instanceof DeviceCommunicationError ? errorArg : new DeviceCommunicationError('WLED returned invalid websocket JSON.'));
+        }
+    };
+    handleError = () => {
+        if (!this.stopping)
+            this.fail(new DeviceCommunicationError('WLED websocket connection failed.'));
+    };
+    handleClose = () => {
+        if (!this.stopping)
+            this.fail(new DeviceCommunicationError('WLED websocket connection closed.'));
+        this.finishClose();
+    };
+    handleAbort = () => { void this.stop(); };
+    fail(errorArg) {
+        this.setHealthy(false);
+        clearTimeout(this.deadline);
+        this.rejectStart?.(errorArg);
+        this.rejectStart = undefined;
+        this.resolveStart = undefined;
+        this.options.onError(errorArg);
+        void this.stop();
+    }
+    setHealthy(valueArg) {
+        if (this.healthy === valueArg)
+            return;
+        this.healthy = valueArg;
+        this.options.onAvailability(valueArg);
+    }
+    finishClose() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        clearTimeout(this.deadline);
+        this.options.signal.removeEventListener('abort', this.handleAbort);
+        this.socket?.removeListener('message', this.handleMessage);
+        this.socket?.removeListener('error', this.handleError);
+        this.socket?.removeListener('close', this.handleClose);
+        this.resolveClose?.();
+        this.resolveClose = undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/wled/wled.commands.d.ts

@@ -0,0 +1,4 @@
+import type { IWledSnapshot, IWledStateChange } from './wled.types.js';
+export declare const wledPlainFields: (valueArg: unknown, fieldsArg: string[], requiredFieldsArg?: string[]) => valueArg is Record<string, unknown>;
+export declare const validateWledChange: (valueArg: unknown) => IWledStateChange;
+export declare const wledPayload: (snapshotArg: IWledSnapshot, segmentIdArg: number | undefined, changeArg: IWledStateChange) => Record<string, unknown>;

package/dist_ts/integrations/wled/wled.commands.js

@@ -0,0 +1,65 @@
+import { isWledRecord, wledInteger } from './wled.validation.js';
+export const wledPlainFields = (valueArg, fieldsArg, requiredFieldsArg = []) => {
+    if (!isWledRecord(valueArg) || Object.getPrototypeOf(valueArg) !== Object.prototype)
+        return false;
+    const descriptors = Object.getOwnPropertyDescriptors(valueArg);
+    return Reflect.ownKeys(valueArg).every((keyArg) => typeof keyArg === 'string' && fieldsArg.includes(keyArg) && 'value' in descriptors[keyArg]) &&
+        requiredFieldsArg.every((keyArg) => descriptors[keyArg] !== undefined && 'value' in descriptors[keyArg]);
+};
+const wledRgb = (valueArg) => {
+    const invalid = () => { throw new Error('WLED RGB requires three own integer color channels between 0 and 255.'); };
+    if (!Array.isArray(valueArg) || valueArg.length !== 3)
+        return invalid();
+    const descriptors = Object.getOwnPropertyDescriptors(valueArg);
+    if (Reflect.ownKeys(valueArg).some((keyArg) => typeof keyArg !== 'string' || !['0', '1', '2', 'length'].includes(keyArg) || !('value' in descriptors[keyArg])))
+        return invalid();
+    const channel = (indexArg) => {
+        const descriptor = descriptors[indexArg];
+        const value = descriptor?.value;
+        if (!descriptor || !('value' in descriptor) || !wledInteger(value, 0, 255))
+            return invalid();
+        return value;
+    };
+    return [channel('0'), channel('1'), channel('2')];
+};
+export const validateWledChange = (valueArg) => {
+    if (!wledPlainFields(valueArg, ['on', 'brightness', 'rgb', 'white']) || Object.keys(valueArg).length === 0)
+        throw new Error('WLED state changes require explicit supported values.');
+    if (valueArg.on !== undefined && typeof valueArg.on !== 'boolean' || valueArg.brightness !== undefined && !wledInteger(valueArg.brightness, 1, 255) || valueArg.white !== undefined && !wledInteger(valueArg.white, 0, 255))
+        throw new Error('WLED requires boolean power and bounded integer brightness or white values.');
+    let rgb;
+    if (valueArg.rgb !== undefined)
+        rgb = wledRgb(valueArg.rgb);
+    const change = { on: valueArg.on, brightness: valueArg.brightness, rgb, white: valueArg.white };
+    if (Object.values(change).every((entryArg) => entryArg === undefined))
+        throw new Error('WLED state changes must contain a value.');
+    return change;
+};
+export const wledPayload = (snapshotArg, segmentIdArg, changeArg) => {
+    const payload = {};
+    if (changeArg.on !== undefined)
+        payload.on = changeArg.on;
+    if (changeArg.brightness !== undefined)
+        payload.bri = changeArg.brightness;
+    if (segmentIdArg === undefined) {
+        if (changeArg.rgb !== undefined || changeArg.white !== undefined)
+            throw new Error('WLED color writes require an exact segment target.');
+        return { ...payload, udpn: { nn: true } };
+    }
+    const segment = snapshotArg.state.seg.find((entryArg) => entryArg.id === segmentIdArg);
+    if (!segment)
+        throw new Error('WLED target segment is not active on the connected controller.');
+    const capabilities = snapshotArg.info.leds.seglc?.[segmentIdArg] ?? 0;
+    if (changeArg.rgb !== undefined && !(capabilities & 1) || changeArg.white !== undefined && (!(capabilities & 2) || segment.col[0].length !== 4))
+        throw new Error('WLED segment does not advertise the requested color capability.');
+    if (changeArg.rgb !== undefined || changeArg.white !== undefined) {
+        const color = [...segment.col[0]];
+        if (changeArg.rgb !== undefined)
+            color.splice(0, 3, ...changeArg.rgb);
+        if (changeArg.white !== undefined)
+            color[3] = changeArg.white;
+        payload.col = [color];
+    }
+    return { seg: [{ id: segmentIdArg, ...payload }], udpn: { nn: true } };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/wled/wled.discovery.d.ts

@@ -1 +1,17 @@
-export declare const createWledDiscoveryDescriptor: () => import("../../core/classes.discoverydescriptor.js").DiscoveryDescriptor;
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import type { IDiscoveryCandidate, IDiscoveryMatch, IDiscoveryMatcher, IDiscoveryValidator } from '../../core/types.js';
+export declare class WledManualMatcher implements IDiscoveryMatcher {
+    readonly id = "wled-manual-match";
+    readonly source: 'manual';
+    matches(valueArg: unknown): Promise<IDiscoveryMatch>;
+}
+export declare class WledMdnsMatcher implements IDiscoveryMatcher {
+    readonly id = "wled-mdns-match";
+    readonly source: 'mdns';
+    matches(valueArg: unknown): Promise<IDiscoveryMatch>;
+}
+export declare class WledCandidateValidator implements IDiscoveryValidator {
+    readonly id = "wled-candidate-validator";
+    validate(valueArg: IDiscoveryCandidate): Promise<IDiscoveryMatch>;
+}
+export declare const createWledDiscoveryDescriptor: () => DiscoveryDescriptor;

package/dist_ts/integrations/wled/wled.discovery.js

@@ -1,4 +1,68 @@
-import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
-import { wledProfile } from './wled.types.js';
-export const createWledDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(wledProfile);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2xlZC5kaXNjb3ZlcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvd2xlZC93bGVkLmRpc2NvdmVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0NBQW9DLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUMzRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFOUMsTUFBTSxDQUFDLE1BQU0sNkJBQTZCLEdBQUcsR0FBRyxFQUFFLENBQUMsb0NBQW9DLENBQUMsV0FBVyxDQUFDLENBQUMifQ==
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import { isWledRecord, normalizeWledMac, wledConfig } from './wled.validation.js';
+const unmatched = () => ({ matched: false, confidence: 'low', reason: 'Record is not an explicit WLED endpoint or official WLED mDNS advertisement.' });
+const plainRecord = (valueArg) => isWledRecord(valueArg) && Object.getPrototypeOf(valueArg) === Object.prototype && Reflect.ownKeys(valueArg).every((keyArg) => typeof keyArg === 'string' && 'value' in Object.getOwnPropertyDescriptor(valueArg, keyArg));
+const candidate = (valueArg, sourceArg) => {
+    if (!plainRecord(valueArg) || valueArg.integrationDomain !== undefined && valueArg.integrationDomain !== 'wled')
+        return unmatched();
+    if (sourceArg === 'manual' && valueArg.integrationDomain !== 'wled')
+        return unmatched();
+    let expectedMac;
+    if (sourceArg === 'mdns') {
+        if (typeof valueArg.type !== 'string' || !/^_wled\._tcp(?:\.local)?\.?$/i.test(valueArg.type) || !plainRecord(valueArg.txt))
+            return unmatched();
+        try {
+            expectedMac = normalizeWledMac(valueArg.txt.mac);
+        }
+        catch {
+            return unmatched();
+        }
+    }
+    else if (valueArg.macAddress !== undefined) {
+        try {
+            expectedMac = normalizeWledMac(valueArg.macAddress);
+        }
+        catch {
+            return unmatched();
+        }
+    }
+    try {
+        const config = wledConfig({ host: valueArg.host, port: valueArg.port, expectedMac });
+        const result = { source: sourceArg, integrationDomain: 'wled', host: config.host, port: config.port, macAddress: expectedMac, manufacturer: 'WLED' };
+        // Discovery data is untrusted; no arbitrary metadata becomes connection settings.
+        return { matched: true, confidence: 'high', reason: 'WLED endpoint admitted; setup will verify its JSON API and MAC.', candidate: result, normalizedDeviceId: expectedMac ? `wled.device.${expectedMac}` : undefined };
+    }
+    catch {
+        return unmatched();
+    }
+};
+export class WledManualMatcher {
+    id = 'wled-manual-match';
+    source = 'manual';
+    async matches(valueArg) { return candidate(valueArg, 'manual'); }
+}
+export class WledMdnsMatcher {
+    id = 'wled-mdns-match';
+    source = 'mdns';
+    async matches(valueArg) { return candidate(valueArg, 'mdns'); }
+}
+export class WledCandidateValidator {
+    id = 'wled-candidate-validator';
+    async validate(valueArg) {
+        if (!plainRecord(valueArg) || valueArg.source !== 'manual' && valueArg.source !== 'mdns' || valueArg.integrationDomain !== 'wled')
+            return unmatched();
+        if (valueArg.source === 'mdns') {
+            try {
+                normalizeWledMac(valueArg.macAddress);
+            }
+            catch {
+                return unmatched();
+            }
+        }
+        const result = candidate(valueArg, 'manual');
+        return result.candidate ? { ...result, candidate: { ...result.candidate, source: valueArg.source === 'mdns' ? 'mdns' : 'manual' } } : result;
+    }
+}
+export const createWledDiscoveryDescriptor = () => new DiscoveryDescriptor({ integrationDomain: 'wled', displayName: 'WLED' })
+    .addMatcher(new WledManualMatcher()).addMatcher(new WledMdnsMatcher()).addValidator(new WledCandidateValidator());
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2xlZC5kaXNjb3ZlcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvd2xlZC93bGVkLmRpc2NvdmVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUVoRixPQUFPLEVBQUUsWUFBWSxFQUFFLGdCQUFnQixFQUFFLFVBQVUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRWxGLE1BQU0sU0FBUyxHQUFHLEdBQW9CLEVBQUUsQ0FBQyxDQUFDLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxVQUFVLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSw4RUFBOEUsRUFBRSxDQUFDLENBQUM7QUFFekssTUFBTSxXQUFXLEdBQUcsQ0FBQyxRQUFpQixFQUF1QyxFQUFFLENBQzdFLFlBQVksQ0FBQyxRQUFRLENBQUMsSUFBSSxNQUFNLENBQUMsY0FBYyxDQUFDLFFBQVEsQ0FBQyxLQUFLLE1BQU0sQ0FBQyxTQUFTLElBQUksT0FBTyxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLE9BQU8sTUFBTSxLQUFLLFFBQVEsSUFBSSxPQUFPLElBQUksTUFBTSxDQUFDLHdCQUF3QixDQUFDLFFBQVEsRUFBRSxNQUFNLENBQUUsQ0FBQyxDQUFDO0FBRTdOLE1BQU0sU0FBUyxHQUFHLENBQUMsUUFBaUIsRUFBRSxTQUE0QixFQUFtQixFQUFFO0lBQ3JGLElBQUksQ0FBQyxXQUFXLENBQUMsUUFBUSxDQUFDLElBQUksUUFBUSxDQUFDLGlCQUFpQixLQUFLLFNBQVMsSUFBSSxRQUFRLENBQUMsaUJBQWlCLEtBQUssTUFBTTtRQUFFLE9BQU8sU0FBUyxFQUFFLENBQUM7SUFDcEksSUFBSSxTQUFTLEtBQUssUUFBUSxJQUFJLFFBQVEsQ0FBQyxpQkFBaUIsS0FBSyxNQUFNO1FBQUUsT0FBTyxTQUFTLEVBQUUsQ0FBQztJQUN4RixJQUFJLFdBQStCLENBQUM7SUFDcEMsSUFBSSxTQUFTLEtBQUssTUFBTSxFQUFFLENBQUM7UUFDekIsSUFBSSxPQUFPLFFBQVEsQ0FBQyxJQUFJLEtBQUssUUFBUSxJQUFJLENBQUMsK0JBQStCLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDO1lBQUUsT0FBTyxTQUFTLEVBQUUsQ0FBQztRQUNoSixJQUFJLENBQUM7WUFBQyxXQUFXLEdBQUcsZ0JBQWdCLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUFDLENBQUM7UUFBQyxNQUFNLENBQUM7WUFBQyxPQUFPLFNBQVMsRUFBRSxDQUFDO1FBQUMsQ0FBQztJQUN6RixDQUFDO1NBQU0sSUFBSSxRQUFRLENBQUMsVUFBVSxLQUFLLFNBQVMsRUFBRSxDQUFDO1FBQzdDLElBQUksQ0FBQztZQUFDLFdBQVcsR0FBRyxnQkFBZ0IsQ0FBQyxRQUFRLENBQUMsVUFBVSxDQUFDLENBQUM7UUFBQyxDQUFDO1FBQUMsTUFBTSxDQUFDO1lBQUMsT0FBTyxTQUFTLEVBQUUsQ0FBQztRQUFDLENBQUM7SUFDNUYsQ0FBQztJQUNELElBQUksQ0FBQztRQUNILE1BQU0sTUFBTSxHQUFHLFVBQVUsQ0FBQyxFQUFFLElBQUksRUFBRSxRQUFRLENBQUMsSUFBSSxFQUFFLElBQUksRUFBRSxRQUFRLENBQUMsSUFBSSxFQUFFLFdBQVcsRUFBRSxDQUFDLENBQUM7UUFDckYsTUFBTSxNQUFNLEdBQXdCLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFJLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLENBQUM7UUFDMUssa0ZBQWtGO1FBQ2xGLE9BQU8sRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLGlFQUFpRSxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsa0JBQWtCLEVBQUUsV0FBVyxDQUFDLENBQUMsQ0FBQyxlQUFlLFdBQVcsRUFBRSxDQUFDLENBQUMsQ0FBQyxTQUFTLEVBQUUsQ0FBQztJQUN6TixDQUFDO0lBQUMsTUFBTSxDQUFDO1FBQUMsT0FBTyxTQUFTLEVBQUUsQ0FBQztJQUFDLENBQUM7QUFDakMsQ0FBQyxDQUFDO0FBRUYsTUFBTSxPQUFPLGlCQUFpQjtJQUNaLEVBQUUsR0FBRyxtQkFBbUIsQ0FBQztJQUN6QixNQUFNLEdBQUcsUUFBaUIsQ0FBQztJQUNwQyxLQUFLLENBQUMsT0FBTyxDQUFDLFFBQWlCLElBQThCLE9BQU8sU0FBUyxDQUFDLFFBQVEsRUFBRSxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUM7Q0FDNUc7QUFFRCxNQUFNLE9BQU8sZUFBZTtJQUNWLEVBQUUsR0FBRyxpQkFBaUIsQ0FBQztJQUN2QixNQUFNLEdBQUcsTUFBZSxDQUFDO0lBQ2xDLEtBQUssQ0FBQyxPQUFPLENBQUMsUUFBaUIsSUFBOEIsT0FBTyxTQUFTLENBQUMsUUFBUSxFQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztDQUMxRztBQUVELE1BQU0sT0FBTyxzQkFBc0I7SUFDakIsRUFBRSxHQUFHLDBCQUEwQixDQUFDO0lBQ3pDLEtBQUssQ0FBQyxRQUFRLENBQUMsUUFBNkI7UUFDakQsSUFBSSxDQUFDLFdBQVcsQ0FBQyxRQUFRLENBQUMsSUFBSSxRQUFRLENBQUMsTUFBTSxLQUFLLFFBQVEsSUFBSSxRQUFRLENBQUMsTUFBTSxLQUFLLE1BQU0sSUFBSSxRQUFRLENBQUMsaUJBQWlCLEtBQUssTUFBTTtZQUFFLE9BQU8sU0FBUyxFQUFFLENBQUM7UUFDdEosSUFBSSxRQUFRLENBQUMsTUFBTSxLQUFLLE1BQU0sRUFBRSxDQUFDO1lBQy9CLElBQUksQ0FBQztnQkFBQyxnQkFBZ0IsQ0FBQyxRQUFRLENBQUMsVUFBVSxDQUFDLENBQUM7WUFBQyxDQUFDO1lBQUMsTUFBTSxDQUFDO2dCQUFDLE9BQU8sU0FBUyxFQUFFLENBQUM7WUFBQyxDQUFDO1FBQzlFLENBQUM7UUFDRCxNQUFNLE1BQU0sR0FBRyxTQUFTLENBQUMsUUFBUSxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBQzdDLE9BQU8sTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxHQUFHLE1BQU0sRUFBRSxTQUFTLEVBQUUsRUFBRSxHQUFHLE1BQU0sQ0FBQyxTQUFTLEVBQUUsTUFBTSxFQUFFLFFBQVEsQ0FBQyxNQUFNLEtBQUssTUFBTSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQztJQUMvSSxDQUFDO0NBQ0Y7QUFFRCxNQUFNLENBQUMsTUFBTSw2QkFBNkIsR0FBRyxHQUF3QixFQUFFLENBQUMsSUFBSSxtQkFBbUIsQ0FBQyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sRUFBRSxXQUFXLEVBQUUsTUFBTSxFQUFFLENBQUM7S0FDaEosVUFBVSxDQUFDLElBQUksaUJBQWlCLEVBQUUsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxJQUFJLGVBQWUsRUFBRSxDQUFDLENBQUMsWUFBWSxDQUFDLElBQUksc0JBQXNCLEVBQUUsQ0FBQyxDQUFDIn0=

package/dist_ts/integrations/wled/wled.errors.d.ts

@@ -0,0 +1,5 @@
+import { DeviceCommunicationError } from '../../core/errors.js';
+export declare class WledWriteError extends DeviceCommunicationError {
+    readonly effectOutcome = "indeterminate";
+    constructor(errorArg: Error);
+}

package/dist_ts/integrations/wled/wled.errors.js

@@ -0,0 +1,9 @@
+import { DeviceCommunicationError } from '../../core/errors.js';
+export class WledWriteError extends DeviceCommunicationError {
+    effectOutcome = 'indeterminate';
+    constructor(errorArg) {
+        super(`${errorArg.message} An unconfirmed WLED write must not be retried automatically.`);
+        this.name = errorArg.name === 'AbortError' ? 'AbortError' : 'WledWriteError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2xlZC5lcnJvcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvd2xlZC93bGVkLmVycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUVoRSxNQUFNLE9BQU8sY0FBZSxTQUFRLHdCQUF3QjtJQUMxQyxhQUFhLEdBQUcsZUFBZSxDQUFDO0lBQ2hELFlBQVksUUFBZTtRQUN6QixLQUFLLENBQUMsR0FBRyxRQUFRLENBQUMsT0FBTywrREFBK0QsQ0FBQyxDQUFDO1FBQzFGLElBQUksQ0FBQyxJQUFJLEdBQUcsUUFBUSxDQUFDLElBQUksS0FBSyxZQUFZLENBQUMsQ0FBQyxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsZ0JBQWdCLENBQUM7SUFDL0UsQ0FBQztDQUNGIn0=

package/dist_ts/integrations/wled/wled.mapper.d.ts

@@ -1,10 +1,10 @@
-import type * as shxInterfaces from '@smarthome.exchange/interfaces';
-import { type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
-import type { IWledConfig } from './wled.types.js';
+import * as plugins from '../../plugins.js';
+import type { IIntegrationEntity } from '../../core/types.js';
+import type { IWledSnapshot } from './wled.types.js';
 export declare class WledMapper {
-    static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IWledConfig>, 'profile'>): ISimpleLocalSnapshot;
-    static toSnapshotFromRaw(configArg: IWledConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot;
-    static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[];
-    static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[];
-    static slug(valueArg: unknown): string;
+    static toSnapshotFromRaw(valueArg: unknown): IWledSnapshot;
+    static deviceId(snapshotArg: IWledSnapshot): string;
+    static entityId(snapshotArg: IWledSnapshot, segmentIdArg?: number): string;
+    static toDevices(snapshotArg: IWledSnapshot, availableArg?: boolean): plugins.shxInterfaces.data.IDeviceDefinition[];
+    static toEntities(snapshotArg: IWledSnapshot, availableArg?: boolean): IIntegrationEntity[];
 }

package/dist_ts/integrations/wled/wled.mapper.js

@@ -1,20 +1,44 @@
-import { SimpleLocalMapper } from '../../core/index.js';
-import { wledProfile } from './wled.types.js';
+import * as plugins from '../../plugins.js';
+import { parseWledSnapshot } from './wled.validation.js';
 export class WledMapper {
-    static toSnapshot(optionsArg) {
-        return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: wledProfile });
+    static toSnapshotFromRaw(valueArg) { return parseWledSnapshot(valueArg); }
+    static deviceId(snapshotArg) { return `wled.device.${snapshotArg.info.mac}`; }
+    static entityId(snapshotArg, segmentIdArg) { return `light.wled_${snapshotArg.info.mac}${segmentIdArg === undefined ? '' : `_segment_${segmentIdArg}`}`; }
+    static toDevices(snapshotArg, availableArg = true) {
+        const features = [];
+        const state = [];
+        const add = (idArg, nameArg, valueArg, writableArg = true) => {
+            features.push({ id: idArg, name: nameArg, capability: writableArg ? 'light' : 'sensor', readable: true, writable: writableArg });
+            state.push({ featureId: idArg, value: valueArg, updatedAt: snapshotArg.updatedAt });
+        };
+        add('power', 'Controller power', snapshotArg.state.on);
+        add('brightness', 'Controller brightness', snapshotArg.state.bri);
+        add('firmware', 'Firmware', snapshotArg.info.ver, false);
+        add('connectivity', 'Connectivity', availableArg ? 'online' : 'offline', false);
+        for (const segment of snapshotArg.state.seg) {
+            const prefix = `segment_${segment.id}`;
+            const name = segment.n || `Segment ${segment.id}`;
+            const capabilities = snapshotArg.info.leds.seglc?.[segment.id] ?? 0;
+            add(`${prefix}_power`, `${name} power`, segment.on);
+            add(`${prefix}_brightness`, `${name} brightness`, segment.bri);
+            if (capabilities & 1)
+                add(`${prefix}_rgb`, `${name} RGB`, `#${segment.col[0].slice(0, 3).map((channelArg) => channelArg.toString(16).padStart(2, '0')).join('')}`);
+            if (capabilities & 2 && segment.col[0].length === 4)
+                add(`${prefix}_white`, `${name} white channel`, segment.col[0][3]);
+        }
+        return [{ id: this.deviceId(snapshotArg), integrationDomain: 'wled', name: snapshotArg.info.name, protocol: 'http', manufacturer: 'WLED', model: snapshotArg.info.product,
+                online: availableArg, features, state, metadata: { macAddress: snapshotArg.info.mac, firmware: snapshotArg.info.ver, ledCount: snapshotArg.info.leds.count } }];
     }
-    static toSnapshotFromRaw(configArg, rawDataArg) {
-        return SimpleLocalMapper.toSnapshot({ profile: wledProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
-    }
-    static toDevices(snapshotArg) {
-        return SimpleLocalMapper.toDevices(wledProfile, snapshotArg);
-    }
-    static toEntities(snapshotArg) {
-        return SimpleLocalMapper.toEntities(wledProfile, snapshotArg);
-    }
-    static slug(valueArg) {
-        return SimpleLocalMapper.slug(valueArg);
+    static toEntities(snapshotArg, availableArg = true) {
+        const deviceId = this.deviceId(snapshotArg);
+        const create = (segmentIdArg) => {
+            const segment = segmentIdArg === undefined ? undefined : snapshotArg.state.seg.find((entryArg) => entryArg.id === segmentIdArg);
+            return { id: this.entityId(snapshotArg, segmentIdArg), uniqueId: this.entityId(snapshotArg, segmentIdArg), integrationDomain: 'wled', deviceId, platform: 'light',
+                name: segment ? segment.n || `Segment ${segment.id}` : snapshotArg.info.name,
+                state: snapshotArg.state.on && (segment?.on ?? true) ? 'on' : 'off', available: availableArg,
+                attributes: segment ? { segmentId: segment.id, segmentPower: segment.on, brightness: segment.bri, primaryColor: [...segment.col[0]], capabilities: snapshotArg.info.leds.seglc?.[segment.id] ?? 0 } : { brightness: snapshotArg.state.bri } };
+        };
+        return [create(), ...snapshotArg.state.seg.map((segmentArg) => create(segmentArg.id))];
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2xlZC5tYXBwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvd2xlZC93bGVkLm1hcHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsaUJBQWlCLEVBQWtILE1BQU0scUJBQXFCLENBQUM7QUFFeEssT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRTlDLE1BQU0sT0FBTyxVQUFVO0lBQ2QsTUFBTSxDQUFDLFVBQVUsQ0FBQyxVQUFxRTtRQUM1RixPQUFPLGlCQUFpQixDQUFDLFVBQVUsQ0FBQyxFQUFFLEdBQUcsVUFBVSxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsQ0FBQyxDQUFDO0lBQy9FLENBQUM7SUFFTSxNQUFNLENBQUMsaUJBQWlCLENBQUMsU0FBc0IsRUFBRSxVQUErQjtRQUNyRixPQUFPLGlCQUFpQixDQUFDLFVBQVUsQ0FBQyxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDeEksQ0FBQztJQUVNLE1BQU0sQ0FBQyxTQUFTLENBQUMsV0FBaUM7UUFDdkQsT0FBTyxpQkFBaUIsQ0FBQyxTQUFTLENBQUMsV0FBVyxFQUFFLFdBQVcsQ0FBQyxDQUFDO0lBQy9ELENBQUM7SUFFTSxNQUFNLENBQUMsVUFBVSxDQUFDLFdBQWlDO1FBQ3hELE9BQU8saUJBQWlCLENBQUMsVUFBVSxDQUFDLFdBQVcsRUFBRSxXQUFXLENBQUMsQ0FBQztJQUNoRSxDQUFDO0lBRU0sTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFpQjtRQUNsQyxPQUFPLGlCQUFpQixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUMxQyxDQUFDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/wled/wled.types.d.ts

@@ -1,11 +1,80 @@
-import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
 export declare const wledDomain = "wled";
 export declare const wledDefaultName = "WLED";
-export type TWledRawData = TSimpleLocalRawData;
-export interface IWledSnapshot extends ISimpleLocalSnapshot {
-}
-export interface IWledConfig extends ISimpleLocalConfig {
+export interface IWledConfig {
+    host: string;
+    port?: number;
+    expectedMac?: string;
+    requestTimeoutMs?: number;
 }
 export interface IHomeAssistantWledConfig extends IWledConfig {
 }
-export declare const wledProfile: ISimpleLocalIntegrationProfile;
+export interface IWledInfo {
+    mac: string;
+    name: string;
+    ver: string;
+    brand: 'WLED';
+    product?: string;
+    ws?: number;
+    leds: {
+        count: number;
+        maxseg: number;
+        seglc?: number[];
+    };
+}
+export interface IWledSegment {
+    id: number;
+    start: number;
+    stop: number;
+    on: boolean;
+    bri: number;
+    col: number[][];
+    n?: string;
+}
+export interface IWledState {
+    on: boolean;
+    bri: number;
+    seg: IWledSegment[];
+}
+export interface IWledSnapshot {
+    info: IWledInfo;
+    state: IWledState;
+    updatedAt: string;
+}
+export type TWledRawData = {
+    info: IWledInfo;
+    state: IWledState;
+};
+export interface IWledStateChange {
+    on?: boolean;
+    brightness?: number;
+    rgb?: [number, number, number];
+    white?: number;
+}
+export type TWledClientEvent = {
+    type: 'snapshot';
+    snapshot: IWledSnapshot;
+} | {
+    type: 'availability';
+    available: boolean;
+} | {
+    type: 'error';
+    error: Error;
+};
+export declare const wledProfile: {
+    readonly domain: "wled";
+    readonly displayName: "WLED";
+    readonly status: 'control-runtime';
+    readonly metadata: {
+        readonly source: 'native-typescript';
+        readonly upstreamDomain: "wled";
+        readonly integrationType: 'device';
+        readonly iotClass: 'local_push';
+        readonly configFlow: true;
+        readonly runtime: {
+            readonly type: 'control-runtime';
+            readonly platforms: readonly ['light'];
+            readonly services: readonly ['turn_on', 'turn_off', 'set_level', 'set_color'];
+            readonly controls: true;
+        };
+    };
+};

package/dist_ts/integrations/wled/wled.types.js

@@ -1,86 +1,16 @@
-export const wledDomain = "wled";
-export const wledDefaultName = "WLED";
+export const wledDomain = 'wled';
+export const wledDefaultName = 'WLED';
 export const wledProfile = {
-    domain: "wled",
-    displayName: "WLED",
-    manufacturer: "WLED",
-    model: "WLED controller",
-    defaultName: "WLED",
-    defaultPort: 80,
-    defaultHttpPath: "/json",
-    defaultProtocol: "http",
-    status: "control-runtime",
-    platforms: [
-        "light",
-        "sensor"
-    ],
-    serviceDomains: [
-        "light"
-    ],
-    controlServices: [
-        "turn_on",
-        "turn_off",
-        "toggle",
-        "set_level"
-    ],
-    discoverySources: [
-        "manual",
-        "mdns",
-        "ssdp",
-        "http",
-        "custom"
-    ],
-    discoveryKeywords: [
-        "wled",
-        "esp8266",
-        "esp32"
-    ],
+    domain: wledDomain,
+    displayName: wledDefaultName,
+    status: 'control-runtime',
     metadata: {
-        source: "home-assistant/core",
-        upstreamPath: "homeassistant/components/wled",
-        upstreamDomain: "wled",
-        integrationType: "device",
-        iotClass: "local_push",
-        qualityScale: "platinum",
-        requirements: [
-            "wled==0.22.0"
-        ],
-        dependencies: [],
-        afterDependencies: [],
-        codeowners: [
-            "@frenck",
-            "@mik-laj"
-        ],
+        source: 'native-typescript',
+        upstreamDomain: wledDomain,
+        integrationType: 'device',
+        iotClass: 'local_push',
         configFlow: true,
-        runtime: {
-            type: "control-runtime",
-            services: [
-                "snapshot",
-                "status",
-                "refresh",
-                "turn_on",
-                "turn_off",
-                "toggle",
-                "set_level"
-            ],
-            platforms: [
-                "light",
-                "sensor"
-            ],
-            controls: true
-        },
-        localApi: {
-            implemented: [
-                "manual local endpoint setup",
-                "snapshot, raw data, snapshotProvider, and injected native client operation",
-                "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
-            ],
-            explicitUnsupported: [
-                "claiming live command success without injected client.execute or commandExecutor",
-                "cloud account flows and remote API polling",
-                "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
-            ]
-        }
-    }
+        runtime: { type: 'control-runtime', platforms: ['light'], services: ['turn_on', 'turn_off', 'set_level', 'set_color'], controls: true },
+    },
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2xlZC50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy93bGVkL3dsZWQudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLE1BQU0sQ0FBQztBQUNqQyxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsTUFBTSxDQUFDO0FBT3RDLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBbUM7SUFDekQsTUFBTSxFQUFFLE1BQU07SUFDZCxXQUFXLEVBQUUsTUFBTTtJQUNuQixZQUFZLEVBQUUsTUFBTTtJQUNwQixLQUFLLEVBQUUsaUJBQWlCO0lBQ3hCLFdBQVcsRUFBRSxNQUFNO0lBQ25CLFdBQVcsRUFBRSxFQUFFO0lBQ2YsZUFBZSxFQUFFLE9BQU87SUFDeEIsZUFBZSxFQUFFLE1BQU07SUFDdkIsTUFBTSxFQUFFLGlCQUFpQjtJQUN6QixTQUFTLEVBQUU7UUFDVCxPQUFPO1FBQ1AsUUFBUTtLQUNUO0lBQ0QsY0FBYyxFQUFFO1FBQ2QsT0FBTztLQUNSO0lBQ0QsZUFBZSxFQUFFO1FBQ2YsU0FBUztRQUNULFVBQVU7UUFDVixRQUFRO1FBQ1IsV0FBVztLQUNaO0lBQ0QsZ0JBQWdCLEVBQUU7UUFDaEIsUUFBUTtRQUNSLE1BQU07UUFDTixNQUFNO1FBQ04sTUFBTTtRQUNOLFFBQVE7S0FDVDtJQUNELGlCQUFpQixFQUFFO1FBQ2pCLE1BQU07UUFDTixTQUFTO1FBQ1QsT0FBTztLQUNSO0lBQ0QsUUFBUSxFQUFFO1FBQ1IsTUFBTSxFQUFFLHFCQUFxQjtRQUM3QixZQUFZLEVBQUUsK0JBQStCO1FBQzdDLGNBQWMsRUFBRSxNQUFNO1FBQ3RCLGVBQWUsRUFBRSxRQUFRO1FBQ3pCLFFBQVEsRUFBRSxZQUFZO1FBQ3RCLFlBQVksRUFBRSxVQUFVO1FBQ3hCLFlBQVksRUFBRTtZQUNaLGNBQWM7U0FDZjtRQUNELFlBQVksRUFBRSxFQUFFO1FBQ2hCLGlCQUFpQixFQUFFLEVBQUU7UUFDckIsVUFBVSxFQUFFO1lBQ1YsU0FBUztZQUNULFVBQVU7U0FDWDtRQUNELFVBQVUsRUFBRSxJQUFJO1FBQ2hCLE9BQU8sRUFBRTtZQUNQLElBQUksRUFBRSxpQkFBaUI7WUFDdkIsUUFBUSxFQUFFO2dCQUNSLFVBQVU7Z0JBQ1YsUUFBUTtnQkFDUixTQUFTO2dCQUNULFNBQVM7Z0JBQ1QsVUFBVTtnQkFDVixRQUFRO2dCQUNSLFdBQVc7YUFDWjtZQUNELFNBQVMsRUFBRTtnQkFDVCxPQUFPO2dCQUNQLFFBQVE7YUFDVDtZQUNELFFBQVEsRUFBRSxJQUFJO1NBQ2Y7UUFDRCxRQUFRLEVBQUU7WUFDUixXQUFXLEVBQUU7Z0JBQ1gsNkJBQTZCO2dCQUM3Qiw0RUFBNEU7Z0JBQzVFLDBHQUEwRzthQUMzRztZQUNELG1CQUFtQixFQUFFO2dCQUNuQixrRkFBa0Y7Z0JBQ2xGLDRDQUE0QztnQkFDNUMsOEZBQThGO2FBQy9GO1NBQ0Y7S0FDRjtDQUNGLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2xlZC50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy93bGVkL3dsZWQudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLE1BQU0sQ0FBQztBQUNqQyxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsTUFBTSxDQUFDO0FBbUR0QyxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUc7SUFDekIsTUFBTSxFQUFFLFVBQVU7SUFDbEIsV0FBVyxFQUFFLGVBQWU7SUFDNUIsTUFBTSxFQUFFLGlCQUFpQjtJQUN6QixRQUFRLEVBQUU7UUFDUixNQUFNLEVBQUUsbUJBQW1CO1FBQzNCLGNBQWMsRUFBRSxVQUFVO1FBQzFCLGVBQWUsRUFBRSxRQUFRO1FBQ3pCLFFBQVEsRUFBRSxZQUFZO1FBQ3RCLFVBQVUsRUFBRSxJQUFJO1FBQ2hCLE9BQU8sRUFBRSxFQUFFLElBQUksRUFBRSxpQkFBaUIsRUFBRSxTQUFTLEVBQUUsQ0FBQyxPQUFPLENBQUMsRUFBRSxRQUFRLEVBQUUsQ0FBQyxTQUFTLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxXQUFXLENBQUMsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFO0tBQ3hJO0NBQ08sQ0FBQyJ9

package/dist_ts/integrations/wled/wled.validation.d.ts

@@ -0,0 +1,7 @@
+import type { IWledConfig, IWledSnapshot } from './wled.types.js';
+export declare const isWledRecord: (valueArg: unknown) => valueArg is Record<string, unknown>;
+export declare const wledInteger: (valueArg: unknown, minArg: number, maxArg: number) => valueArg is number;
+export declare const normalizeWledMac: (valueArg: unknown) => string;
+export declare const wledConfig: (valueArg: unknown) => IWledConfig;
+export declare const wledEndpoint: (configArg: IWledConfig) => URL;
+export declare const parseWledSnapshot: (valueArg: unknown, expectedMacArg?: string) => IWledSnapshot;