node-red-contrib-homekit-bridged 2.0.0-dev.1 → 2.0.0-dev.10

package/build/plugins/registry/index.js

@@ -0,0 +1,203 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var registry_exports = {};
+__export(registry_exports, {
+  NRCHKB_NODE_RED_PLUGIN_TYPE: () => NRCHKB_NODE_RED_PLUGIN_TYPE,
+  clearPluginsForTest: () => clearPluginsForTest,
+  getPlugin: () => getPlugin,
+  listPlugins: () => listPlugins,
+  normalizePluginId: () => normalizePluginId,
+  registerNodeRedPlugins: () => registerNodeRedPlugins,
+  registerPlugin: () => registerPlugin,
+  registerPluginFromModule: () => registerPluginFromModule,
+  registerPluginFromPackage: () => registerPluginFromPackage,
+  validatePluginMetadata: () => validatePluginMetadata
+});
+module.exports = __toCommonJS(registry_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_url = require("node:url");
+const NRCHKB_NODE_RED_PLUGIN_TYPE = "nrchkb-homekit-plugin";
+const registry = /* @__PURE__ */ new Map();
+const normalizePluginId = (packageName, pluginName) => `${packageName}:${pluginName}`;
+const assertNonEmpty = (field, value) => {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Plugin metadata field "${field}" is required.`);
+  }
+};
+const validatePluginMetadata = (metadata) => {
+  assertNonEmpty("packageName", metadata.packageName);
+  assertNonEmpty("pluginName", metadata.pluginName);
+  assertNonEmpty("displayName", metadata.displayName);
+  assertNonEmpty("author", metadata.author);
+  assertNonEmpty("version", metadata.version);
+  assertNonEmpty("description", metadata.description);
+  if (!metadata.capabilities || typeof metadata.capabilities !== "object") {
+    throw new Error('Plugin metadata field "capabilities" is required.');
+  }
+  if (metadata.prerequisites?.serviceNames && (!Array.isArray(metadata.prerequisites.serviceNames) || metadata.prerequisites.serviceNames.some(
+    (serviceName) => typeof serviceName !== "string" || serviceName.trim().length === 0
+  ))) {
+    throw new Error(
+      "Plugin metadata prerequisites.serviceNames must be an array of service names."
+    );
+  }
+  if (metadata.serviceNames) {
+    if (!Array.isArray(metadata.serviceNames) || metadata.serviceNames.some(
+      (serviceName) => typeof serviceName !== "string" || serviceName.trim().length === 0
+    )) {
+      throw new Error(
+        "Plugin metadata serviceNames must be an array of service names."
+      );
+    }
+  }
+  if (metadata.attachment && !["inline", "config-node"].includes(metadata.attachment)) {
+    throw new Error(
+      'Plugin metadata attachment must be "inline" or "config-node".'
+    );
+  }
+  if (metadata.editor && (!Array.isArray(metadata.editor.sections) || metadata.editor.sections.some(
+    (section) => section.title !== void 0 && typeof section.title !== "string" || section.description !== void 0 && typeof section.description !== "string" || section.icon !== void 0 && typeof section.icon !== "string" || section.collapsed !== void 0 && typeof section.collapsed !== "boolean" || !Array.isArray(section.fields) || section.fields.some(
+      (field) => typeof field.path !== "string" || field.path.trim().length === 0 || typeof field.label !== "string" || field.label.trim().length === 0 || ![
+        "text",
+        "number",
+        "checkbox",
+        "select",
+        "password",
+        "textarea",
+        "config-node",
+        "dynamic-select"
+      ].includes(field.type)
+    )
+  ))) {
+    throw new Error(
+      "Plugin metadata editor.sections must contain valid editor field definitions."
+    );
+  }
+  const expectedId = normalizePluginId(
+    metadata.packageName,
+    metadata.pluginName
+  );
+  if (metadata.id !== expectedId) {
+    throw new Error(
+      `Plugin id "${metadata.id}" must match normalized id "${expectedId}".`
+    );
+  }
+  return {
+    ...metadata,
+    attachment: metadata.attachment ?? "inline"
+  };
+};
+const registerPlugin = (metadata, factory) => {
+  const validMetadata = validatePluginMetadata(metadata);
+  if (registry.has(validMetadata.id)) {
+    throw new Error(`Plugin "${validMetadata.id}" is already registered.`);
+  }
+  const plugin = {
+    metadata: validMetadata,
+    factory
+  };
+  registry.set(validMetadata.id, plugin);
+  return plugin;
+};
+const registerPluginFromPackage = (packageJson, metadata, factory) => {
+  const packageName = metadata.packageName ?? packageJson.name;
+  const version = metadata.version ?? packageJson.version;
+  if (!packageName) {
+    throw new Error("Plugin packageName could not be resolved.");
+  }
+  if (!version) {
+    throw new Error("Plugin version could not be resolved.");
+  }
+  return registerPlugin(
+    {
+      ...metadata,
+      packageName,
+      version,
+      id: metadata.id ?? normalizePluginId(packageName, metadata.pluginName)
+    },
+    factory
+  );
+};
+const findNearestPackageJson = (startFile) => {
+  let current = import_node_path.default.dirname(startFile);
+  while (current !== import_node_path.default.dirname(current)) {
+    const candidate = import_node_path.default.join(current, "package.json");
+    if (import_node_fs.default.existsSync(candidate)) {
+      return JSON.parse(import_node_fs.default.readFileSync(candidate, "utf8"));
+    }
+    current = import_node_path.default.dirname(current);
+  }
+  throw new Error(`Could not find package.json for ${startFile}.`);
+};
+const registerPluginFromModule = (importMetaUrl, metadata, factory) => {
+  const modulePath = (0, import_node_url.fileURLToPath)(importMetaUrl);
+  const packageJson = findNearestPackageJson(modulePath);
+  if (metadata.packageName && metadata.packageName !== packageJson.name) {
+    throw new Error(
+      `Plugin packageName "${metadata.packageName}" does not match nearest package "${packageJson.name}".`
+    );
+  }
+  return registerPluginFromPackage(packageJson, metadata, factory);
+};
+const getPlugin = (id) => registry.get(id);
+const listPlugins = () => Array.from(registry.values());
+const registerNodeRedPlugins = (RED) => {
+  const nodeRedPlugins = RED?.plugins?.getPluginsByType?.(
+    NRCHKB_NODE_RED_PLUGIN_TYPE
+  );
+  nodeRedPlugins?.forEach((definition) => {
+    if (definition.type !== NRCHKB_NODE_RED_PLUGIN_TYPE || !definition.metadata || !definition.factory || registry.has(definition.metadata.id)) {
+      return;
+    }
+    try {
+      registerPlugin(definition.metadata, definition.factory);
+    } catch (error) {
+      RED?.log?.warn?.(
+        `Skipping NRCHKB plugin "${definition.metadata.id}" because registration failed: ${error}`
+      );
+    }
+  });
+};
+const clearPluginsForTest = () => {
+  registry.clear();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NRCHKB_NODE_RED_PLUGIN_TYPE,
+  clearPluginsForTest,
+  getPlugin,
+  listPlugins,
+  normalizePluginId,
+  registerNodeRedPlugins,
+  registerPlugin,
+  registerPluginFromModule,
+  registerPluginFromPackage,
+  validatePluginMetadata
+});

package/build/plugins/registry/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/build/scripts/migrate-homekit-service-flows.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+"use strict";
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_HomeKitService2Migration = require("../lib/migration/HomeKitService2Migration");
+const usage = () => {
+  console.error(
+    "Usage: node build/scripts/migrate-homekit-service-flows.js <flow-file.json> [output-file.json]"
+  );
+};
+const parseFlowFile = (filePath) => {
+  const content = (0, import_node_fs.readFileSync)(filePath, "utf8");
+  return JSON.parse(content);
+};
+const migrate = (flowPath) => {
+  const parsed = parseFlowFile(flowPath);
+  if (!Array.isArray(parsed)) {
+    throw new Error(
+      "Flow file must contain a JSON array of Node-RED nodes."
+    );
+  }
+  return (0, import_HomeKitService2Migration.migrateHomeKitServiceFlow)(parsed);
+};
+const [, , inputPath, outputPath] = process.argv;
+if (!inputPath) {
+  usage();
+  process.exitCode = 1;
+} else {
+  try {
+    const inputFile = (0, import_node_path.resolve)(inputPath);
+    const result = migrate(inputFile);
+    const destination = outputPath ? (0, import_node_path.resolve)(outputPath) : inputFile;
+    (0, import_node_fs.writeFileSync)(
+      destination,
+      `${JSON.stringify(result.nodes, null, 4)}
+`,
+      "utf8"
+    );
+    console.log(
+      `Migrated ${result.migrated} homekit-service node(s), including ${result.cameraMigrated} camera node(s); skipped ${result.skipped}.`
+    );
+    console.log(`Wrote ${destination}`);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+  }
+}