@espressif/rainmaker-neo-base-sdk 1.0.0

package/dist/esm/utils/scheduleUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduleUtils.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/utils/shadowUtils.js

@@ -0,0 +1,67 @@
+import { Logger } from './logger.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("ShadowUtils");
+/**
+ * Constructs a shadow name based on group ID and subgroups
+ * @param groupId The group ID
+ * @param subgroups Array of subgroup IDs
+ * @returns The constructed shadow name
+ */
+function constructShadowName(groupId, subgroups = []) {
+    let shadowName = `params-${groupId}`;
+    if (subgroups.length > 0) {
+        const sortedSubgroups = [...subgroups].sort();
+        shadowName += `-${sortedSubgroups.join("-")}`;
+    }
+    return shadowName;
+}
+/**
+ * Constructs a shadow topic for a device
+ * @param nodeId The node ID
+ * @param groupId The group ID
+ * @param subgroups Array of subgroup IDs
+ * @returns The constructed shadow topic
+ */
+function constructShadowTopic(nodeId, groupId, subgroups) {
+    const shadowName = constructShadowName(groupId, subgroups);
+    return `$aws/things/${nodeId}/shadow/name/${shadowName}`;
+}
+/**
+ * Constructs a device parameters topic
+ * @param nodeId The node ID
+ * @param groupId The group ID
+ * @param subgroups Array of subgroup IDs
+ * @returns The constructed parameters topic
+ */
+function constructDeviceParamsTopic(nodeId, groupId, subgroups) {
+    const shadowName = constructShadowName(groupId, subgroups);
+    return `rainmaker/nodes/${nodeId}/user/${shadowName}/params`;
+}
+/**
+ * Generates a digest for parameters to detect changes
+ * @param params The parameters object
+ * @returns A digest string representing the parameters
+ */
+function generateParamsDigest(params) {
+    try {
+        const sortedParams = Object.keys(params)
+            .sort()
+            .reduce((result, key) => {
+            result[key] = params[key];
+            return result;
+        }, {});
+        return JSON.stringify(sortedParams);
+    }
+    catch (error) {
+        logger.error("Error generating params digest:", error);
+        return "";
+    }
+}
+
+export { constructDeviceParamsTopic, constructShadowName, constructShadowTopic, generateParamsDigest };
+//# sourceMappingURL=shadowUtils.js.map

package/dist/esm/utils/shadowUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadowUtils.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/utils/triggerUtils.js

@@ -0,0 +1,55 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Converts a trigger-like object to TriggerItem (for building payloads).
+ */
+function triggerToItem(t) {
+    return {
+        id: t.id,
+        type: t.type,
+        enabled: t.enabled,
+        path: t.path,
+        operator: t.operator,
+        value: t.value,
+    };
+}
+/**
+ * Fetches the current trigger list for a node as TriggerItem[].
+ * Always hits the cloud — the triggers API is replace-all.
+ */
+async function getTriggerItemsForNode(node) {
+    const triggers = await node.getTriggers();
+    return triggers.map((t) => triggerToItem(t));
+}
+/**
+ * Merges defined update fields onto a base TriggerItem without writing
+ * `undefined` over existing values.
+ */
+function mergeTriggerItem(base, updates) {
+    return {
+        ...base,
+        ...(updates.path !== undefined ? { path: updates.path } : {}),
+        ...(updates.enabled !== undefined ? { enabled: updates.enabled } : {}),
+        ...(updates.operator !== undefined ? { operator: updates.operator } : {}),
+        ...(updates.value !== undefined ? { value: updates.value } : {}),
+    };
+}
+/**
+ * Copies defined update fields onto a live trigger instance.
+ */
+function applyTriggerUpdates(target, updates) {
+    if (updates.path !== undefined)
+        target.path = updates.path;
+    if (updates.enabled !== undefined)
+        target.enabled = updates.enabled;
+    if (updates.operator !== undefined)
+        target.operator = updates.operator;
+    if (updates.value !== undefined)
+        target.value = updates.value;
+}
+
+export { applyTriggerUpdates, getTriggerItemsForNode, mergeTriggerItem, triggerToItem };
+//# sourceMappingURL=triggerUtils.js.map

package/dist/esm/utils/triggerUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"triggerUtils.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/utils/tsDataUtils.js

@@ -0,0 +1,156 @@
+import { APICallValidationErrorCodes } from './constants.js';
+import { ESPAPICallValidationError } from './error/ESPAPICallValidationError.js';
+import { Logger } from './logger.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("TSDataUtils");
+/** Param property flag marking a param as time-series capable (node config). */
+const TIME_SERIES_PROPERTY = "time_series";
+const AGGREGATION_WINDOWS = [
+    "hourly",
+    "daily",
+    "weekly",
+    "monthly",
+];
+/**
+ * Returns the explicit query identity from options when the caller provided
+ * one, bypassing any node-config lookup. This is the escape hatch for data
+ * models the default lookup cannot resolve (e.g. Matter attributes).
+ *
+ * @throws {ESPAPICallValidationError} If `options.key` is set without `options.dataType`.
+ */
+function tsParamIdentityFromOptions(options) {
+    if (!options?.key)
+        return undefined;
+    if (!options.dataType) {
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_TS_CUSTOM_KEY_DATA_TYPE);
+    }
+    return { key: options.key, dataType: options.dataType };
+}
+/**
+ * Builds the backend query identity from a device param's own metadata
+ * (used by the param-level methods, where `this` IS the param).
+ *
+ * @throws {ESPAPICallValidationError} If no data type can be determined.
+ */
+function tsParamIdentityFromParam(param, options) {
+    const explicit = tsParamIdentityFromOptions(options);
+    if (explicit)
+        return explicit;
+    const key = `${param.deviceName}.${param.id}`;
+    if (!param.properties?.includes(TIME_SERIES_PROPERTY)) {
+        logger.warn(`Param "${key}" does not declare the "${TIME_SERIES_PROPERTY}" property; the backend may have no data for it`);
+    }
+    const dataType = options?.dataType ?? param.dataType;
+    if (!dataType) {
+        logger.error(`Param "${key}" has no data_type`);
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_TS_DATA_TYPE);
+    }
+    return { key, dataType };
+}
+/**
+ * Resolves the backend query identity for a device param by looking it up in
+ * the node's config (used by the node-level methods).
+ *
+ * @throws {ESPAPICallValidationError} If the param is not found on the node's config.
+ */
+function resolveTSParamIdentity(node, deviceName, paramId, options) {
+    const explicit = tsParamIdentityFromOptions(options);
+    if (explicit)
+        return explicit;
+    const device = node.devices?.find((d) => d.name === deviceName);
+    const param = device?.params?.find((p) => p.id === paramId);
+    if (!param) {
+        logger.error(`Param "${paramId}" not found on device "${deviceName}" of node "${node.nodeId}"`);
+        throw new ESPAPICallValidationError(APICallValidationErrorCodes.TS_PARAM_NOT_FOUND);
+    }
+    return tsParamIdentityFromParam(param, options);
+}
+/**
+ * Resolves the aggregation window from options.
+ *
+ * @throws {ESPAPICallValidationError} If no valid window is provided.
+ */
+function resolveTSWindow(options) {
+    const candidate = options?.window;
+    if (typeof candidate === "string" &&
+        AGGREGATION_WINDOWS.includes(candidate)) {
+        return candidate;
+    }
+    throw new ESPAPICallValidationError(APICallValidationErrorCodes.INVALID_TS_WINDOW);
+}
+/**
+ * Builds a URL query string from the given params, skipping undefined values.
+ */
+function buildTSQueryString(params) {
+    const parts = [];
+    for (const [name, value] of Object.entries(params)) {
+        if (value === undefined)
+            continue;
+        parts.push(`${encodeURIComponent(name)}=${encodeURIComponent(String(value))}`);
+    }
+    return parts.join("&");
+}
+/**
+ * Maps a raw API sample into an {@link ESPRMNeoTSDataPoint}.
+ * The backend emits `key`; older swagger examples show `name` — both accepted.
+ */
+function transformTSDataPoint(point) {
+    return {
+        timestamp: point.ts,
+        value: point.value,
+        dataType: point.dt,
+        timezone: point.tz,
+        cumulative: point.cumulative,
+    };
+}
+function transformTSWindowAggregate(aggregate) {
+    const { first_value: firstValue, last_value: lastValue, cumulative_value: cumulativeValue, window_start: windowStart, window_end: windowEnd, ...rest } = aggregate;
+    return {
+        ...rest,
+        firstValue,
+        lastValue,
+        cumulativeValue,
+        windowStart,
+        windowEnd,
+    };
+}
+/**
+ * Maps a raw API aggregate entry into an {@link ESPRMNeoTSAggregateEntry}.
+ *
+ * The backend emits two entry shapes:
+ * - **Nested** (`windows: {hourly: {...}, ...}`) — only the current-aggregates
+ *   query with no `window` param (all windows at once).
+ * - **Flat** — historical `date`/`start_date`+`end_date` queries and the
+ *   current-single-window query put the stats directly on the entry
+ *   (`{date, window_start, count, average, ...}`), with no `windows` map.
+ *
+ * Flat entries are nested under `requestedWindow` so consumers always read
+ * `entry.windows[window]` regardless of query mode.
+ */
+function transformTSAggregateEntry(entry, requestedWindow) {
+    const { is_cumulative: isCumulative, windows: rawWindows, ...rest } = entry;
+    const windows = {};
+    if (rawWindows && Object.keys(rawWindows).length > 0) {
+        for (const [windowName, aggregate] of Object.entries(rawWindows)) {
+            windows[windowName] =
+                transformTSWindowAggregate(aggregate);
+        }
+        return { ...rest, isCumulative, windows };
+    }
+    if (requestedWindow) {
+        // Flat entry: everything except the entry-level identity fields is the
+        // window's stat set.
+        const { date, parameter, ...flatStats } = rest;
+        windows[requestedWindow] = transformTSWindowAggregate(flatStats);
+        return { date, parameter, isCumulative, windows };
+    }
+    return { ...rest, isCumulative, windows };
+}
+
+export { TIME_SERIES_PROPERTY, buildTSQueryString, resolveTSParamIdentity, resolveTSWindow, transformTSAggregateEntry, transformTSDataPoint, tsParamIdentityFromOptions, tsParamIdentityFromParam };
+//# sourceMappingURL=tsDataUtils.js.map

package/dist/esm/utils/tsDataUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsDataUtils.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/utils/userUtils.js

@@ -0,0 +1,54 @@
+import { ESPRMNeoStorage } from '../services/ESPRMNeoStorage/ESPRMNeoStorage.js';
+import { ESPRMNeoAPIManager } from '../services/ESPRMNeoAPIManager.js';
+import { StorageKeys, APIPathV1 } from './constants.js';
+import { clearAllNcfgVersionMarkers } from './nodeNcfgVersionHandler.js';
+import { Logger } from './logger.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("userUtils");
+function errorDetail(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Runs an action without letting failures abort the caller. */
+async function failSafe(step, action) {
+    try {
+        await action();
+        logger.debug(`${step} succeeded`);
+    }
+    catch (error) {
+        logger.warn(`${step} failed`, { error: errorDetail(error) });
+    }
+}
+/** Best-effort `POST /v1/user/auth/signout` when an access token is present. */
+async function invalidateServerSession() {
+    const accessToken = (await ESPRMNeoStorage.getItem(StorageKeys.ACCESSTOKEN)) || undefined;
+    if (!accessToken) {
+        logger.debug("Skipping server signout: no access token");
+        return;
+    }
+    const refreshToken = (await ESPRMNeoStorage.getItem(StorageKeys.REFRESHTOKEN)) || undefined;
+    const requestBody = refreshToken
+        ? { refresh_token: refreshToken }
+        : undefined;
+    await ESPRMNeoAPIManager.getInstance().postUserApiWithBearer(APIPathV1.USER_AUTH_SIGNOUT, requestBody, accessToken);
+}
+/** Removes access, id, and refresh tokens from storage. */
+async function clearTokens() {
+    await ESPRMNeoStorage.removeItem(StorageKeys.ACCESSTOKEN);
+    await ESPRMNeoStorage.removeItem(StorageKeys.IDTOKEN);
+    await ESPRMNeoStorage.removeItem(StorageKeys.REFRESHTOKEN);
+}
+/**
+ * Clears ncfg version markers and every cached node config they referenced.
+ */
+async function clearNodeConfigCache() {
+    const trackedNodeIds = await clearAllNcfgVersionMarkers();
+    await Promise.all(trackedNodeIds.map((nodeId) => ESPRMNeoStorage.removeItem(StorageKeys.NODE_CONFIG_PREFIX + nodeId).catch(() => undefined)));
+}
+
+export { clearNodeConfigCache, clearTokens, errorDetail, failSafe, invalidateServerSession };
+//# sourceMappingURL=userUtils.js.map

package/dist/esm/utils/userUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"userUtils.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/utils/validator/ConfigValidator.js

@@ -0,0 +1,214 @@
+import { isValidObject, isNonEmptyString, isValidUrl } from './validators.js';
+import { ESPConfigError } from '../error/ESPConfigError.js';
+import { ConfigErrorCodes } from '../constants.js';
+import '../logger.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Methods every custom storage adapter must implement. */
+const STORAGE_ADAPTER_METHODS = [
+    "setItem",
+    "getItem",
+    "removeItem",
+    "clear",
+];
+/** Required methods for an MQTT transport (`once` is optional per interface). */
+const MQTT_ADAPTER_METHODS = [
+    "connect",
+    "disconnect",
+    "isConnected",
+    "publish",
+    "subscribe",
+    "unsubscribe",
+];
+/** Required methods for a provisioning adapter. */
+const PROVISION_ADAPTER_METHODS = [
+    "searchESPDevices",
+    "stopESPDevicesSearch",
+    "createESPDevice",
+    "connect",
+    "getDeviceCapabilities",
+    "getDeviceVersion",
+    "setProofOfPossession",
+    "initializeSession",
+    "scanWifiList",
+    "sendData",
+    "provision",
+    "disconnect",
+];
+/** Required methods for a local control adapter. */
+const LOCAL_CONTROL_ADAPTER_METHODS = [
+    "isConnected",
+    "connect",
+    "sendData",
+];
+/** Required methods for a local discovery adapter. */
+const LOCAL_DISCOVERY_ADAPTER_METHODS = [
+    "startDiscovery",
+    "stopDiscovery",
+];
+/**
+ * A class that validates configuration objects for the ESP RainMaker Neo SDK.
+ *
+ * This class provides methods to ensure that the provided configuration
+ * adheres to the required structure and rules for URLs, versions, and other fields.
+ */
+class ConfigValidator {
+    /**
+     * Validates the given authentication configuration.
+     *
+     * @param config - The authentication configuration object to validate.
+     * @throws {ESPConfigError} If the configuration is invalid.
+     */
+    static validateConfig(config) {
+        ConfigValidator.validateConfigObject(config);
+        ConfigValidator.validateBaseUrl(config.baseUrl);
+        ConfigValidator.validateUserApiBase(config.userApiBase);
+        ConfigValidator.validateRegion(config.awsRegion);
+        ConfigValidator.validateIotEndpoint(config.iotEndpoint);
+        ConfigValidator.validateCustomStorageAdapter(config.customStorageAdapter);
+        ConfigValidator.validateMQTTAdapter(config.mqttAdapter);
+        ConfigValidator.validateProvisionAdapter(config.provisionAdapter);
+        ConfigValidator.validateLocalControlAdapter(config.localControlAdapter);
+        ConfigValidator.validateLocalDiscoveryAdapter(config.localDiscoveryAdapter);
+    }
+    /**
+     * Validates that the provided configuration object is valid.
+     *
+     * @param config - The configuration object to validate.
+     * @throws {ESPConfigError} If the configuration object is invalid.
+     */
+    static validateConfigObject(config) {
+        if (!isValidObject(config)) {
+            throw new ESPConfigError(ConfigErrorCodes.INVALID_CONFIG_OBJECT);
+        }
+    }
+    /**
+     * Validates the base URL of the configuration.
+     *
+     * @param baseUrl - The base URL to validate.
+     * @throws {ESPConfigError} If the base URL is invalid or empty.
+     */
+    static validateBaseUrl(baseUrl) {
+        if (!isNonEmptyString(baseUrl) || !isValidUrl(baseUrl)) {
+            throw new ESPConfigError(ConfigErrorCodes.INVALID_BASE_URL);
+        }
+    }
+    /**
+     * Validates the User/auth API base URL of the configuration.
+     *
+     * @param userApiBase - The User API base URL to validate.
+     * @throws {ESPConfigError} If the User API base URL is invalid or empty.
+     */
+    static validateUserApiBase(userApiBase) {
+        if (!isNonEmptyString(userApiBase) || !isValidUrl(userApiBase)) {
+            throw new ESPConfigError(ConfigErrorCodes.INVALID_USER_API_BASE);
+        }
+    }
+    /**
+     * Validates the AWS region.
+     *
+     * @param region - The AWS region to validate.
+     * @throws {ESPConfigError} If the region is invalid or empty.
+     */
+    static validateRegion(region) {
+        if (!isNonEmptyString(region)) {
+            throw new ESPConfigError(ConfigErrorCodes.INVALID_REGION);
+        }
+    }
+    /**
+     * Validates the IoT endpoint (used for MQTT and SigV4-signed connections).
+     * Accepts either a hostname (e.g. `xxxxx-ats.iot.region.amazonaws.com`) or a
+     * full `wss://…/mqtt` URL; both forms are normalised downstream.
+     *
+     * @param iotEndpoint - The IoT endpoint string to validate.
+     * @throws {ESPConfigError} If the endpoint is missing or empty.
+     */
+    static validateIotEndpoint(iotEndpoint) {
+        if (!isNonEmptyString(iotEndpoint)) {
+            throw new ESPConfigError(ConfigErrorCodes.INVALID_IOT_ENDPOINT);
+        }
+    }
+    /**
+     * Validates that an adapter is an object and implements every method in
+     * {@link requiredMethods}. Throws with {@link errorCode} on the first
+     * missing method.
+     */
+    static validateAdapterShape(adapter, requiredMethods, errorCode) {
+        if (!isValidObject(adapter)) {
+            throw new ESPConfigError(errorCode);
+        }
+        const record = adapter;
+        for (const method of requiredMethods) {
+            if (typeof record[method] !== "function") {
+                throw new ESPConfigError(errorCode);
+            }
+        }
+    }
+    /**
+     * Validates the custom storage adapter if provided.
+     *
+     * @param adapter - The custom storage adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link ESPStorageAdapter} contract.
+     */
+    static validateCustomStorageAdapter(adapter) {
+        if (adapter === undefined)
+            return;
+        ConfigValidator.validateAdapterShape(adapter, STORAGE_ADAPTER_METHODS, ConfigErrorCodes.INVALID_STORAGE_ADAPTER);
+    }
+    /**
+     * Validates the MQTT adapter if provided.
+     *
+     * @param adapter - The MQTT adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link MQTTTransport} contract.
+     */
+    static validateMQTTAdapter(adapter) {
+        if (adapter === undefined)
+            return;
+        ConfigValidator.validateAdapterShape(adapter, MQTT_ADAPTER_METHODS, ConfigErrorCodes.INVALID_MQTT_ADAPTER);
+    }
+    /**
+     * Validates the provisioning adapter if provided.
+     *
+     * @param adapter - The provisioning adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link ESPProvisionAdapterInterface} contract.
+     */
+    static validateProvisionAdapter(adapter) {
+        if (adapter === undefined)
+            return;
+        ConfigValidator.validateAdapterShape(adapter, PROVISION_ADAPTER_METHODS, ConfigErrorCodes.INVALID_PROVISION_ADAPTER);
+    }
+    /**
+     * Validates the local control adapter if provided.
+     *
+     * @param adapter - The local control adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link ESPLocalControlAdapterInterface} contract.
+     */
+    static validateLocalControlAdapter(adapter) {
+        if (adapter === undefined)
+            return;
+        ConfigValidator.validateAdapterShape(adapter, LOCAL_CONTROL_ADAPTER_METHODS, ConfigErrorCodes.INVALID_LOCAL_CONTROL_ADAPTER);
+    }
+    /**
+     * Validates the local discovery adapter if provided.
+     *
+     * @param adapter - The local discovery adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link ESPLocalDiscoveryAdapterInterface} contract.
+     */
+    static validateLocalDiscoveryAdapter(adapter) {
+        if (adapter === undefined)
+            return;
+        ConfigValidator.validateAdapterShape(adapter, LOCAL_DISCOVERY_ADAPTER_METHODS, ConfigErrorCodes.INVALID_LOCAL_DISCOVERY_ADAPTER);
+    }
+}
+
+export { ConfigValidator };
+//# sourceMappingURL=ConfigValidator.js.map

package/dist/esm/utils/validator/ConfigValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigValidator.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/utils/validator/ScheduleValidator.js

@@ -0,0 +1,56 @@
+import { APICallValidationErrorCodes } from '../constants.js';
+import { ESPAPICallValidationError } from '../error/ESPAPICallValidationError.js';
+import { isNonEmptyString, isValidObject } from './validators.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Validates schedule payloads used by group/node schedule APIs.
+ */
+class ScheduleValidator {
+    /**
+     * Validates the `nodeSchedules` argument for `createSchedule`.
+     *
+     * @param nodeSchedules - Per-node schedule batches to validate.
+     * @throws {ESPAPICallValidationError} If the payload shape is invalid.
+     */
+    static validateNodeSchedules(nodeSchedules) {
+        if (!Array.isArray(nodeSchedules)) {
+            throw new ESPAPICallValidationError(APICallValidationErrorCodes.INVALID_NODE_SCHEDULES);
+        }
+        for (const { nodeId, schedules } of nodeSchedules) {
+            if (!isNonEmptyString(nodeId)) {
+                throw new ESPAPICallValidationError(APICallValidationErrorCodes.MISSING_NODE_ID);
+            }
+            if (!Array.isArray(schedules)) {
+                throw new ESPAPICallValidationError(APICallValidationErrorCodes.INVALID_SCHEDULES);
+            }
+            for (const schedule of schedules) {
+                ScheduleValidator.validateScheduleItem(schedule);
+            }
+        }
+    }
+    /**
+     * Validates a single schedule item.
+     *
+     * @param item - The schedule item to validate.
+     * @throws {ESPAPICallValidationError} If required fields are missing or invalid.
+     */
+    static validateScheduleItem(item) {
+        if (typeof item?.enabled !== "boolean") {
+            throw new ESPAPICallValidationError(APICallValidationErrorCodes.INVALID_SCHEDULE_ENABLED);
+        }
+        if (!Array.isArray(item.triggers)) {
+            throw new ESPAPICallValidationError(APICallValidationErrorCodes.INVALID_SCHEDULE_TRIGGERS);
+        }
+        if (!isValidObject(item.action)) {
+            throw new ESPAPICallValidationError(APICallValidationErrorCodes.INVALID_SCHEDULE_ACTION);
+        }
+    }
+}
+
+export { ScheduleValidator };
+//# sourceMappingURL=ScheduleValidator.js.map

package/dist/esm/utils/validator/ScheduleValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduleValidator.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/utils/validator/validators.js

@@ -0,0 +1,38 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Checks if a string is not empty.
+ * @param value - The string to check.
+ * @returns True if the string is not empty, false otherwise.
+ */
+const isNonEmptyString = (value) => {
+    return typeof value === "string" && value.trim().length > 0;
+};
+/**
+ * Validates if a given string is a valid URL.
+ * @param url - The URL string to validate.
+ * @returns True if the URL is valid, false otherwise.
+ */
+const isValidUrl = (url) => {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Checks if a value is a valid object (not null and type object).
+ * @param value - The value to check.
+ * @returns True if the value is a valid object, false otherwise.
+ */
+const isValidObject = (value) => {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+};
+
+export { isNonEmptyString, isValidObject, isValidUrl };
+//# sourceMappingURL=validators.js.map

package/dist/esm/utils/validator/validators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}