@smarthome.exchange/integrations 1.0.0 → 3.0.0

package/dist_ts/integrations/onkyo/onkyo.types.js

@@ -1,109 +1,20 @@
-export const onkyoDomain = "onkyo";
-export const onkyoDefaultName = "Onkyo";
+export const onkyoDomain = 'onkyo';
+export const onkyoDefaultName = 'Onkyo';
 export const onkyoDefaultPort = 60128;
 export const onkyoDefaultTimeoutMs = 5000;
 export const onkyoProfile = {
-    domain: onkyoDomain,
-    displayName: "Onkyo",
-    manufacturer: "Onkyo",
-    model: "Onkyo local integration",
-    defaultName: onkyoDefaultName,
-    defaultPort: onkyoDefaultPort,
-    defaultProtocol: 'tcp',
-    status: "control-runtime",
-    platforms: [
-        "media_player",
-        "switch",
-    ],
-    serviceDomains: [
-        "media_player",
-        "switch",
-    ],
-    controlServices: [
-        "media_pause",
-        "media_play",
-        "media_stop",
-        "select_source",
-        "toggle",
-        "turn_off",
-        "turn_on",
-        "volume_down",
-        "volume_mute",
-        "volume_set",
-        "volume_up",
-        "onkyo_select_hdmi_output",
-    ],
-    discoverySources: [
-        'manual',
-        'custom',
-    ],
-    discoveryKeywords: [
-        "onkyo",
-        "Onkyo",
-    ],
+    domain: onkyoDomain, displayName: onkyoDefaultName, status: 'control-runtime',
     metadata: {
-        "source": "home-assistant/core",
-        "upstreamPath": "homeassistant/components/onkyo",
-        "upstreamDomain": "onkyo",
-        "integrationType": "device",
-        "iotClass": "local_push",
-        "qualityScale": "bronze",
-        "requirements": [
-            "aioonkyo==0.4.0",
-        ],
-        "dependencies": [
-            "network",
-        ],
-        "codeowners": [
-            "@arturpragacz",
-            "@eclair4151",
-        ],
-        "configFlow": true,
-        "documentation": "https://www.home-assistant.io/integrations/onkyo",
-        "loggers": [
-            "aioonkyo",
-        ],
-        "runtime": {
-            "type": "control-runtime",
-            "services": [
-                "snapshot",
-                "status",
-                "refresh",
-                "media_pause",
-                "media_play",
-                "media_stop",
-                "select_source",
-                "toggle",
-                "turn_off",
-                "turn_on",
-                "volume_down",
-                "volume_mute",
-                "volume_set",
-                "volume_up",
-                "onkyo_select_hdmi_output",
-            ],
-            "platforms": [
-                "media_player",
-                "switch",
-            ],
-            "controls": "native eISCP TCP commands for main-zone media controls; injected client.execute or commandExecutor remains supported",
-        },
-        "localApi": {
-            "status": "Native Onkyo/Pioneer eISCP TCP polling and main-zone control are implemented for manual host/port configurations; UDP discovery/interview and persistent push subscriptions are not implemented.",
-            "implemented": [
-                "native eISCP TCP polling on port 60128 for main-zone power, volume, mute, input source, and listening mode status",
-                "native eISCP TCP control for power, volume, mute, source selection, HDMI output, and NET play/pause/stop commands",
-                "manual local setup for Onkyo endpoints, snapshots, rawData, snapshotProvider, and injected native clients",
-                "runtime mapping for Onkyo device snapshots and Home Assistant platform metadata",
-                "safe command delegation to injected client.execute or commandExecutor when no live eISCP host is configured",
-            ],
-            "explicitUnsupported": [
-                "UDP eISCP discovery/interview broadcast semantics; use manual host configuration or external discovery metadata",
-                "persistent local_push subscription and unsolicited status update processing; this client performs focused request/response TCP polling and commands",
-                "multi-zone and channel-muting switch discovery beyond main-zone eISCP status/control",
-                "Home Assistant entity registry migrations and repair flows",
-            ],
+        source: 'home-assistant/core', upstreamDomain: onkyoDomain, configFlow: true,
+        localApi: {
+            status: 'Selected native Onkyo main-zone eISCP TCP through devicemanager.',
+            implemented: ['selected unicast UDP advertisement', 'live MAC/model and enabled main-zone admission',
+                'explicit power/mute, advertised input selectors and bounded absolute integer raw volume',
+                'explicit captured host home and optional actual caller-owned NoSQL store', 'events from explicit observations and joined terminal shutdown'],
+            explicitUnsupported: ['broadcast discovery', 'cloud access', 'injected clients and snapshots', 'other zones',
+                'percentage or half-step volume conversion', 'toggle/increment/media transport/arbitrary commands',
+                'automatic reconnect, effect retry or replay', 'unsolicited push subscription', 'cryptographic LAN peer authentication'],
         },
     },
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25reW8udHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvb25reW8vb25reW8udHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLE9BQU8sQ0FBQztBQUNuQyxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxPQUFPLENBQUM7QUFDeEMsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsS0FBSyxDQUFDO0FBQ3RDLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLElBQUksQ0FBQztBQTZDMUMsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHO0lBQzFCLE1BQU0sRUFBRSxXQUFXLEVBQUUsV0FBVyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sRUFBRSxpQkFBaUI7SUFDN0UsUUFBUSxFQUFFO1FBQ1IsTUFBTSxFQUFFLHFCQUFxQixFQUFFLGNBQWMsRUFBRSxXQUFXLEVBQUUsVUFBVSxFQUFFLElBQUk7UUFDNUUsUUFBUSxFQUFFO1lBQ1IsTUFBTSxFQUFFLGtFQUFrRTtZQUMxRSxXQUFXLEVBQUUsQ0FBQyxvQ0FBb0MsRUFBRSxnREFBZ0Q7Z0JBQ2xHLHlGQUF5RjtnQkFDekYsMEVBQTBFLEVBQUUsZ0VBQWdFLENBQUM7WUFDL0ksbUJBQW1CLEVBQUUsQ0FBQyxxQkFBcUIsRUFBRSxjQUFjLEVBQUUsZ0NBQWdDLEVBQUUsYUFBYTtnQkFDMUcsMkNBQTJDLEVBQUUscURBQXFEO2dCQUNsRyw2Q0FBNkMsRUFBRSwrQkFBK0IsRUFBRSx1Q0FBdUMsQ0FBQztTQUMzSDtLQUNGO0NBQ08sQ0FBQyJ9

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

@@ -0,0 +1,16 @@
+import type { IOnkyoConfig } from './onkyo.types.js';
+interface IOnkyoNormalizedConfig extends IOnkyoConfig {
+    port: number;
+    requestTimeoutMs: number;
+    maxPendingOperations: number;
+}
+export declare function onkyoRecord(valueArg: unknown, nameArg: string): Record<string, unknown>;
+export declare function onkyoKeys(recordArg: Record<string, unknown>, keysArg: readonly string[]): void;
+export declare function onkyoInteger(valueArg: unknown, minimumArg: number, maximumArg: number, nameArg: string): number;
+export declare function onkyoName(valueArg: unknown, nameArg: string): string;
+export declare function onkyoHost(valueArg: unknown): string;
+export declare function readOnkyoEndpoint(hostArg: unknown, macArg: unknown, modelArg: unknown, portArg?: unknown): Pick<IOnkyoNormalizedConfig, 'host' | 'macAddress' | 'model' | 'port'>;
+export declare function normalizeOnkyoConfig(valueArg: unknown): Readonly<IOnkyoNormalizedConfig>;
+export declare function onkyoBoolean(valueArg: unknown, nameArg: string): boolean;
+export declare function onkyoInputId(valueArg: unknown): string;
+export {};

package/dist_ts/integrations/onkyo/onkyo.validation.js

@@ -0,0 +1,77 @@
+import * as plugins from '../../plugins.js';
+import { onkyoDefaultPort, onkyoDefaultTimeoutMs } from './onkyo.types.js';
+export function onkyoRecord(valueArg, nameArg) {
+    if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg) ||
+        ![Object.prototype, null].includes(Object.getPrototypeOf(valueArg))) {
+        throw new TypeError(`Onkyo ${nameArg} must be a plain data object.`);
+    }
+    const result = {};
+    for (const key of Reflect.ownKeys(valueArg)) {
+        const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+        if (typeof key !== 'string' || !descriptor || !('value' in descriptor) || !descriptor.enumerable) {
+            throw new TypeError(`Onkyo ${nameArg} may not contain symbols, accessors or hidden fields.`);
+        }
+        Object.defineProperty(result, key, { value: descriptor.value, enumerable: true });
+    }
+    return result;
+}
+export function onkyoKeys(recordArg, keysArg) {
+    if (Object.keys(recordArg).some((keyArg) => !keysArg.includes(keyArg)))
+        throw new TypeError('Onkyo data contains unsupported fields.');
+}
+export function onkyoInteger(valueArg, minimumArg, maximumArg, nameArg) {
+    if (typeof valueArg !== 'number' || !Number.isSafeInteger(valueArg) || valueArg < minimumArg || valueArg > maximumArg) {
+        throw new RangeError(`Onkyo ${nameArg} must be an integer from ${minimumArg} through ${maximumArg}.`);
+    }
+    return valueArg;
+}
+export function onkyoName(valueArg, nameArg) {
+    if (typeof valueArg !== 'string' || !valueArg.trim() || valueArg.length > 256 || /[\p{Cc}\p{Cs}]/u.test(valueArg)) {
+        throw new TypeError(`Onkyo ${nameArg} must be a non-empty string without control characters, at most 256 characters.`);
+    }
+    return valueArg;
+}
+export function onkyoHost(valueArg) {
+    if (typeof valueArg !== 'string' || plugins.net.isIP(valueArg) !== 4)
+        throw new TypeError('Onkyo host must be a selected unicast IPv4 address.');
+    const octets = valueArg.split('.').map(Number);
+    const local = octets[0] === 10 || octets[0] === 127 || octets[0] === 192 && octets[1] === 168 ||
+        octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31 || octets[0] === 169 && octets[1] === 254;
+    if (!local || octets[3] === 255)
+        throw new TypeError('Onkyo host must be a private, loopback or link-local unicast IPv4 address.');
+    return valueArg;
+}
+export function readOnkyoEndpoint(hostArg, macArg, modelArg, portArg) {
+    const host = onkyoHost(hostArg);
+    if (typeof macArg !== 'string' || !/^[0-9a-f]{12}$/i.test(macArg) || /^(0{12}|f{12})$/i.test(macArg)) {
+        throw new TypeError('Onkyo macAddress must be a nonempty twelve-digit receiver MAC.');
+    }
+    if (typeof modelArg !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9 ._-]{0,63}$/.test(modelArg))
+        throw new TypeError('Onkyo model must be the exact selected receiver model.');
+    return { host, macAddress: macArg.toUpperCase(), model: modelArg,
+        port: onkyoInteger(portArg === undefined ? onkyoDefaultPort : portArg, 1, 65535, 'port') };
+}
+export function normalizeOnkyoConfig(valueArg) {
+    const config = onkyoRecord(valueArg, 'configuration');
+    onkyoKeys(config, ['homeId', 'host', 'macAddress', 'model', 'allowUnencryptedLan', 'volumeLimitRaw', 'port', 'name', 'requestTimeoutMs', 'maxPendingOperations']);
+    if (config.allowUnencryptedLan !== true)
+        throw new TypeError('Onkyo requires an explicit allowUnencryptedLan: true acknowledgement.');
+    return Object.freeze({
+        homeId: onkyoName(config.homeId, 'homeId'), ...readOnkyoEndpoint(config.host, config.macAddress, config.model, config.port),
+        allowUnencryptedLan: true, volumeLimitRaw: onkyoInteger(config.volumeLimitRaw, 0, 100, 'volumeLimitRaw'),
+        name: config.name === undefined ? undefined : onkyoName(config.name, 'name'),
+        requestTimeoutMs: onkyoInteger(config.requestTimeoutMs === undefined ? onkyoDefaultTimeoutMs : config.requestTimeoutMs, 1, 60000, 'requestTimeoutMs'),
+        maxPendingOperations: onkyoInteger(config.maxPendingOperations === undefined ? 16 : config.maxPendingOperations, 1, 128, 'maxPendingOperations'),
+    });
+}
+export function onkyoBoolean(valueArg, nameArg) {
+    if (typeof valueArg !== 'boolean')
+        throw new TypeError(`Onkyo ${nameArg} requires an explicit boolean.`);
+    return valueArg;
+}
+export function onkyoInputId(valueArg) {
+    if (typeof valueArg !== 'string' || !/^[0-9a-f]{2}$/i.test(valueArg))
+        throw new TypeError('Onkyo input requires an advertised two-digit selector ID.');
+    return valueArg.toUpperCase();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/panasonic_viera/panasonic_viera.classes.client.d.ts

@@ -1,27 +1,27 @@
-import { SimpleLocalClient, type ISimpleLocalSnapshot, type IServiceCallRequest, type IServiceCallResult } from '../../core/index.js';
-import type { IPanasonicVieraConfig } from './panasonic_viera.types.js';
-export declare class PanasonicVieraClient extends SimpleLocalClient<IPanasonicVieraConfig> {
-    private readonly clientConfig;
-    private cachedSnapshot?;
-    private encryptedSession?;
-    constructor(clientConfig: IPanasonicVieraConfig);
-    getSnapshot(forceRefreshArg?: boolean): Promise<ISimpleLocalSnapshot>;
-    refresh(): Promise<IServiceCallResult>;
-    execute(requestArg: IServiceCallRequest): Promise<IServiceCallResult>;
+import type { IPanasonicVieraClientOptions, IPanasonicVieraConfig, IPanasonicVieraSnapshot, TPanasonicVieraKey, TPanasonicVieraKeyReceipt } from './panasonic_viera.types.js';
+export declare class PanasonicVieraClient {
+    private readonly config;
+    private readonly protocol;
+    private readonly lifetime;
+    private readonly operations;
+    private readonly ownerSignal?;
+    private readonly onDestroyed?;
+    private state;
+    private closePromise?;
+    private retryPromise?;
+    private cleanupComplete;
+    private readonly onOwnerAbort;
+    constructor(configArg: IPanasonicVieraConfig, optionsArg: IPanasonicVieraClientOptions);
+    get isClosed(): boolean;
+    get isHealthy(): boolean;
+    start(abortSignalArg?: AbortSignal): Promise<IPanasonicVieraSnapshot>;
+    getSnapshot(abortSignalArg?: AbortSignal): Promise<IPanasonicVieraSnapshot>;
+    sendKey(keyArg: TPanasonicVieraKey, abortSignalArg?: AbortSignal): Promise<TPanasonicVieraKeyReceipt>;
     destroy(): Promise<void>;
-    private fetchRawData;
-    private getVolume;
-    private setVolume;
-    private getMute;
-    private setMute;
-    private sendKey;
-    private soapRequest;
-    private shouldEncrypt;
-    private ensureEncryptedSession;
-    private encryptSoapPayload;
-    private decryptSoapPayload;
-    private requestText;
-    private requireEndpoint;
-    private endpoint;
-    private createOfflineSnapshot;
+    /** Explicit cleanup retry only. The original destroy rejection remains observable; transport work is never replayed. */
+    retryCleanup(): Promise<void>;
+    private snapshot;
+    private operationSignal;
+    private assertOpen;
+    private track;
 }