@esphome/compose 0.0.1

package/dist/index.js

@@ -0,0 +1,635 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ESPCompose: () => ESPCompose,
+  ESPHomeRegistry: () => ESPHomeRegistry,
+  Fragment: () => Fragment,
+  RefHandle: () => RefHandle,
+  assertHookCall: () => assertHookCall,
+  createContext: () => createContext,
+  createElement: () => createElement,
+  delay: () => delay,
+  findInScope: () => findInScope,
+  getCurrentComponentName: () => getCurrentComponentName,
+  getCurrentHookIndex: () => getCurrentHookIndex,
+  getCurrentHookPath: () => getCurrentHookPath,
+  isRef: () => isRef,
+  logger: () => logger,
+  registerInScope: () => registerInScope,
+  render: () => render,
+  setCurrentComponentName: () => setCurrentComponentName,
+  setCurrentHookIndex: () => setCurrentHookIndex,
+  setCurrentHookPath: () => setCurrentHookPath,
+  toYAML: () => toYAML,
+  useContext: () => useContext,
+  useRef: () => useRef,
+  useScript: () => useScript,
+  withContext: () => withContext,
+  withScriptScope: () => withScriptScope
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/runtime.ts
+var import_yaml = __toESM(require("yaml"));
+
+// src/types.ts
+var RefHandle = class {
+  _token;
+  constructor() {
+    this._token = `r_${Math.random().toString(36).slice(2, 11)}`;
+  }
+  toString() {
+    return this._token;
+  }
+  toJSON() {
+    return this._token;
+  }
+};
+function useRef() {
+  return new RefHandle();
+}
+function isRef(val) {
+  return val instanceof RefHandle;
+}
+
+// src/hooks/useState.ts
+var _currentHookPath = null;
+var _currentHookIndex = 0;
+var _currentComponentName = null;
+function setCurrentHookPath(path) {
+  _currentHookPath = path;
+  _currentHookIndex = 0;
+}
+function getCurrentHookPath() {
+  return _currentHookPath;
+}
+function setCurrentHookIndex(index) {
+  _currentHookIndex = index;
+}
+function getCurrentHookIndex() {
+  return _currentHookIndex;
+}
+function setCurrentComponentName(name) {
+  _currentComponentName = name;
+}
+function getCurrentComponentName() {
+  return _currentComponentName;
+}
+function assertHookCall() {
+  if (!_currentHookPath) {
+    throw new Error(
+      "Hooks must be called within a function component during render. This error occurs when a hook (useScript, etc.) is called outside of a component render context."
+    );
+  }
+}
+
+// src/hooks/useContext.ts
+var contextMap = /* @__PURE__ */ new Map();
+function createContext(defaultValue) {
+  return { id: /* @__PURE__ */ Symbol(), value: defaultValue };
+}
+function withContext(ctx, value, fn) {
+  let stack = contextMap.get(ctx.id);
+  if (!stack) {
+    stack = [];
+    contextMap.set(ctx.id, stack);
+  }
+  stack.push(value);
+  try {
+    return fn();
+  } finally {
+    stack.pop();
+  }
+}
+function useContext(ctx) {
+  const stack = contextMap.get(ctx.id);
+  if (stack && stack.length > 0) return stack[stack.length - 1];
+  return ctx.value;
+}
+
+// src/hooks/useScope.ts
+var scriptScopeContext = createContext({ value: {} });
+function findInScope(id) {
+  let frame = useContext(scriptScopeContext);
+  let found = frame.value[id];
+  while (!found && frame.next) {
+    frame = frame.next;
+    found = frame.value[id];
+  }
+  return found;
+}
+function registerInScope(id, entry) {
+  const frame = useContext(scriptScopeContext);
+  frame.value[id] = entry;
+}
+function withScriptScope(fn) {
+  const prev = useContext(scriptScopeContext);
+  const scopeFrame = { next: prev, value: {} };
+  setCurrentHookPath("espcompose_script_render");
+  try {
+    const result = withContext(scriptScopeContext, scopeFrame, fn);
+    const scripts = Object.values(scopeFrame.value).map((e) => e.def);
+    return { result, scripts };
+  } finally {
+    setCurrentHookPath(null);
+  }
+}
+
+// src/hooks/useScript.ts
+function useScript(metadata) {
+  assertHookCall();
+  if (findInScope(metadata.id)) {
+    return [{ "script.execute": metadata.id }];
+  }
+  registerInScope(metadata.id, { def: metadata });
+  return [{ "script.execute": metadata.id }];
+}
+
+// src/runtime.ts
+function camelToSnake(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function keysToSnakeCase(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    out[camelToSnake(k)] = serializeValue(v);
+  }
+  return out;
+}
+function serializeValue(v) {
+  if (isRef(v)) return v.toString();
+  if (Array.isArray(v)) return v.map(serializeValue);
+  if (v !== null && typeof v === "object") {
+    return keysToSnakeCase(v);
+  }
+  return v;
+}
+function createElement(type, props, ...children) {
+  const flatChildren = children.flat().filter((c) => c != null);
+  return {
+    type,
+    props: {
+      ...props ?? {},
+      ...flatChildren.length > 0 ? { children: flatChildren } : {}
+    }
+  };
+}
+function Fragment(props) {
+  const { children } = props;
+  if (children == null) return null;
+  return Array.isArray(children) ? children : [children];
+}
+function toPlainObject(el) {
+  if (el == null) return void 0;
+  if (Array.isArray(el)) {
+    const mapped = el.map(toPlainObject).filter((v) => v != null);
+    return mapped.length === 1 ? mapped[0] : mapped;
+  }
+  if (typeof el.type === "function") {
+    const result = el.type(el.props);
+    if (result == null) return void 0;
+    return toPlainObject(Array.isArray(result) ? result : result);
+  }
+  const { children, ref, "x:custom": xCustom, ...ownProps } = el.props;
+  const propsWithId = ref != null ? { id: isRef(ref) ? ref.toString() : String(ref), ...ownProps } : ownProps;
+  const allProps = xCustom != null ? { ...propsWithId, ...xCustom } : propsWithId;
+  if (el.type === "esphome") {
+    const childSections = childrenToTopLevelSections(
+      children
+    );
+    return {
+      esphome: stripUndefined(keysToSnakeCase(allProps)),
+      ...childSections
+    };
+  }
+  const childData = buildChildData(
+    children
+  );
+  const data = stripUndefined(keysToSnakeCase({ ...allProps, ...childData }));
+  return { [el.type]: Object.keys(data).length > 0 ? data : null };
+}
+function childrenToTopLevelSections(children) {
+  if (!children) return {};
+  const normalized = flattenFragments(Array.isArray(children) ? children : [children]);
+  const sections = {};
+  for (const child of normalized) {
+    if (typeof child.type === "function") {
+      const result = child.type(child.props);
+      if (result == null) continue;
+      const rendered = Array.isArray(result) ? result : [result];
+      const inner = flattenFragments(rendered);
+      for (const c of inner) {
+        mergeSection(sections, c);
+      }
+    } else {
+      mergeSection(sections, child);
+    }
+  }
+  const out = {};
+  for (const [key, values] of Object.entries(sections)) {
+    out[key] = values.length === 1 ? values[0] : values;
+  }
+  return out;
+}
+function mergeSection(sections, child) {
+  const { children: grandchildren, ref, "x:custom": xCustom, ...ownProps } = child.props;
+  const propsWithId = ref != null ? { id: isRef(ref) ? ref.toString() : String(ref), ...ownProps } : ownProps;
+  const allProps = xCustom != null ? { ...propsWithId, ...xCustom } : propsWithId;
+  const childData = buildChildData(
+    grandchildren
+  );
+  const data = stripUndefined(keysToSnakeCase({ ...allProps, ...childData }));
+  if (!sections[child.type]) sections[child.type] = [];
+  sections[child.type].push(Object.keys(data).length > 0 ? data : null);
+}
+function buildChildData(children) {
+  if (!children) return {};
+  const arr = Array.isArray(children) ? children : [children];
+  const out = {};
+  for (const child of arr) {
+    const plain = toPlainObject(child);
+    if (plain != null && typeof plain === "object" && !Array.isArray(plain)) {
+      Object.assign(out, plain);
+    }
+  }
+  return out;
+}
+function flattenFragments(elements) {
+  const out = [];
+  for (const el of elements) {
+    if (el.type === Fragment) {
+      const result = Fragment(el.props);
+      if (result != null) {
+        const nested = Array.isArray(result) ? result : [result];
+        out.push(...flattenFragments(nested));
+      }
+    } else {
+      out.push(el);
+    }
+  }
+  return out;
+}
+function stripUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+function render(element) {
+  return toPlainObject(Array.isArray(element) ? element : element);
+}
+function toYAML(config) {
+  return import_yaml.default.stringify(config, { aliasDuplicateObjects: false, nullStr: "" });
+}
+var ESPCompose = {
+  createElement,
+  Fragment,
+  render,
+  toYAML,
+  useScript,
+  withScriptScope
+};
+
+// src/actions.ts
+function delay(_ms) {
+}
+var logger = {
+  /**
+   * Emit a log message at the given level.
+   *
+   * Compiles to:  `logger.log:\n  message: <message>\n  level: <level>`
+   *
+   * @espcomposeAction logger.log
+   *
+   * @param message - The message string to emit.
+   * @param level   - Log level: "VERBOSE", "DEBUG", "INFO", "WARN", "ERROR".
+   *                  Defaults to "DEBUG" in ESPHome when omitted.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  log(_message, _level) {
+  }
+};
+
+// src/generated/registry.ts
+var ESPHomeRegistry = {
+  adalight: { yamlKey: "adalight" },
+  adc128s102: { yamlKey: "adc128s102" },
+  ads1115: { yamlKey: "ads1115" },
+  ads1118: { yamlKey: "ads1118" },
+  airthings_ble: { yamlKey: "airthings_ble" },
+  alarm_control_panel: { yamlKey: "alarm_control_panel" },
+  animation: { yamlKey: "animation" },
+  apds9960: { yamlKey: "apds9960" },
+  api: { yamlKey: "api" },
+  as3935_i2c: { yamlKey: "as3935_i2c" },
+  as3935_spi: { yamlKey: "as3935_spi" },
+  as5600: { yamlKey: "as5600" },
+  async_tcp: { yamlKey: "async_tcp" },
+  at581x: { yamlKey: "at581x" },
+  audio: { yamlKey: "audio" },
+  audio_adc: { yamlKey: "audio_adc" },
+  audio_dac: { yamlKey: "audio_dac" },
+  audio_file: { yamlKey: "audio_file" },
+  bedjet: { yamlKey: "bedjet" },
+  binary_sensor: { yamlKey: "binary_sensor" },
+  bk72xx: { yamlKey: "bk72xx" },
+  ble_client: { yamlKey: "ble_client" },
+  ble_nus: { yamlKey: "ble_nus" },
+  bluetooth_proxy: { yamlKey: "bluetooth_proxy" },
+  bme680_bsec: { yamlKey: "bme680_bsec" },
+  bme68x_bsec2_i2c: { yamlKey: "bme68x_bsec2_i2c" },
+  bp1658cj: { yamlKey: "bp1658cj" },
+  bp5758d: { yamlKey: "bp5758d" },
+  button: { yamlKey: "button" },
+  bytebuffer: { yamlKey: "bytebuffer" },
+  camera_encoder: { yamlKey: "camera_encoder" },
+  canbus: { yamlKey: "canbus" },
+  cap1188: { yamlKey: "cap1188" },
+  captive_portal: { yamlKey: "captive_portal" },
+  cc1101: { yamlKey: "cc1101" },
+  cd74hc4067: { yamlKey: "cd74hc4067" },
+  ch422g: { yamlKey: "ch422g" },
+  ch423: { yamlKey: "ch423" },
+  climate: { yamlKey: "climate" },
+  color: { yamlKey: "color" },
+  cover: { yamlKey: "cover" },
+  custom_component: { yamlKey: "custom_component" },
+  dac7678: { yamlKey: "dac7678" },
+  dallas: { yamlKey: "dallas" },
+  daly_bms: { yamlKey: "daly_bms" },
+  dashboard_import: { yamlKey: "dashboard_import" },
+  datetime: { yamlKey: "datetime" },
+  debug: { yamlKey: "debug" },
+  deep_sleep: { yamlKey: "deep_sleep" },
+  demo: { yamlKey: "demo" },
+  dfplayer: { yamlKey: "dfplayer" },
+  dfrobot_sen0395: { yamlKey: "dfrobot_sen0395" },
+  display: { yamlKey: "display" },
+  dlms_meter: { yamlKey: "dlms_meter" },
+  dsmr: { yamlKey: "dsmr" },
+  e131: { yamlKey: "e131" },
+  emc2101: { yamlKey: "emc2101" },
+  esp_ldo: { yamlKey: "esp_ldo" },
+  esp32: { yamlKey: "esp32" },
+  esp32_ble: { yamlKey: "esp32_ble" },
+  esp32_ble_beacon: { yamlKey: "esp32_ble_beacon" },
+  esp32_ble_server: { yamlKey: "esp32_ble_server" },
+  esp32_ble_tracker: { yamlKey: "esp32_ble_tracker" },
+  esp32_camera: { yamlKey: "esp32_camera" },
+  esp32_camera_web_server: { yamlKey: "esp32_camera_web_server" },
+  esp32_hosted: { yamlKey: "esp32_hosted" },
+  esp32_improv: { yamlKey: "esp32_improv" },
+  esp32_touch: { yamlKey: "esp32_touch" },
+  esp8266: { yamlKey: "esp8266" },
+  esphome: { yamlKey: "esphome" },
+  espnow: { yamlKey: "espnow" },
+  ethernet: { yamlKey: "ethernet" },
+  event: { yamlKey: "event" },
+  exposure_notifications: { yamlKey: "exposure_notifications" },
+  external_components: { yamlKey: "external_components" },
+  ezo_pmp: { yamlKey: "ezo_pmp" },
+  factory_reset: { yamlKey: "factory_reset" },
+  fan: { yamlKey: "fan" },
+  fingerprint_grow: { yamlKey: "fingerprint_grow" },
+  font: { yamlKey: "font" },
+  gdk101: { yamlKey: "gdk101" },
+  globals: { yamlKey: "globals" },
+  gp8403: { yamlKey: "gp8403" },
+  gps: { yamlKey: "gps" },
+  graph: { yamlKey: "graph" },
+  graphical_display_menu: { yamlKey: "graphical_display_menu" },
+  grove_tb6612fng: { yamlKey: "grove_tb6612fng" },
+  hlk_fm22x: { yamlKey: "hlk_fm22x" },
+  hmac_md5: { yamlKey: "hmac_md5" },
+  hmac_sha256: { yamlKey: "hmac_sha256" },
+  host: { yamlKey: "host" },
+  http_request: { yamlKey: "http_request" },
+  i2c: { yamlKey: "i2c" },
+  i2c_device: { yamlKey: "i2c_device" },
+  i2s_audio: { yamlKey: "i2s_audio" },
+  image: { yamlKey: "image" },
+  improv_serial: { yamlKey: "improv_serial" },
+  infrared: { yamlKey: "infrared" },
+  interval: { yamlKey: "interval" },
+  json: { yamlKey: "json" },
+  key_collector: { yamlKey: "key_collector" },
+  lcd_menu: { yamlKey: "lcd_menu" },
+  ld2410: { yamlKey: "ld2410" },
+  ld2412: { yamlKey: "ld2412" },
+  ld2420: { yamlKey: "ld2420" },
+  ld2450: { yamlKey: "ld2450" },
+  libretiny: { yamlKey: "libretiny" },
+  light: { yamlKey: "light" },
+  lightwaverf: { yamlKey: "lightwaverf" },
+  ln882x: { yamlKey: "ln882x" },
+  lock: { yamlKey: "lock" },
+  logger: { yamlKey: "logger" },
+  lvgl: { yamlKey: "lvgl" },
+  m5stack_8angle: { yamlKey: "m5stack_8angle" },
+  mapping: { yamlKey: "mapping" },
+  matrix_keypad: { yamlKey: "matrix_keypad" },
+  max6956: { yamlKey: "max6956" },
+  mcp23008: { yamlKey: "mcp23008" },
+  mcp23016: { yamlKey: "mcp23016" },
+  mcp23017: { yamlKey: "mcp23017" },
+  mcp23s08: { yamlKey: "mcp23s08" },
+  mcp23s17: { yamlKey: "mcp23s17" },
+  mcp3008: { yamlKey: "mcp3008" },
+  mcp3204: { yamlKey: "mcp3204" },
+  mcp4461: { yamlKey: "mcp4461" },
+  mcp4728: { yamlKey: "mcp4728" },
+  mdns: { yamlKey: "mdns" },
+  media_player: { yamlKey: "media_player" },
+  media_source: { yamlKey: "media_source" },
+  micro_wake_word: { yamlKey: "micro_wake_word" },
+  micronova: { yamlKey: "micronova" },
+  microphone: { yamlKey: "microphone" },
+  modbus: { yamlKey: "modbus" },
+  modbus_controller: { yamlKey: "modbus_controller" },
+  mopeka_ble: { yamlKey: "mopeka_ble" },
+  mpr121: { yamlKey: "mpr121" },
+  mqtt: { yamlKey: "mqtt" },
+  msa3xx: { yamlKey: "msa3xx" },
+  my9231: { yamlKey: "my9231" },
+  network: { yamlKey: "network" },
+  nrf52: { yamlKey: "nrf52" },
+  number: { yamlKey: "number" },
+  one_wire: { yamlKey: "one_wire" },
+  online_image: { yamlKey: "online_image" },
+  opentherm: { yamlKey: "opentherm" },
+  openthread: { yamlKey: "openthread" },
+  ota: { yamlKey: "ota" },
+  output: { yamlKey: "output" },
+  packages: { yamlKey: "packages" },
+  packet_transport: { yamlKey: "packet_transport" },
+  pca6416a: { yamlKey: "pca6416a" },
+  pca9554: { yamlKey: "pca9554" },
+  pca9685: { yamlKey: "pca9685" },
+  pcf8574: { yamlKey: "pcf8574" },
+  pi4ioe5v6408: { yamlKey: "pi4ioe5v6408" },
+  pipsolar: { yamlKey: "pipsolar" },
+  pn532: { yamlKey: "pn532" },
+  pn532_i2c: { yamlKey: "pn532_i2c" },
+  pn532_spi: { yamlKey: "pn532_spi" },
+  pn7150_i2c: { yamlKey: "pn7150_i2c" },
+  pn7160_i2c: { yamlKey: "pn7160_i2c" },
+  pn7160_spi: { yamlKey: "pn7160_spi" },
+  power_supply: { yamlKey: "power_supply" },
+  preferences: { yamlKey: "preferences" },
+  prometheus: { yamlKey: "prometheus" },
+  psram: { yamlKey: "psram" },
+  pylontech: { yamlKey: "pylontech" },
+  qr_code: { yamlKey: "qr_code" },
+  radon_eye_ble: { yamlKey: "radon_eye_ble" },
+  rc522_i2c: { yamlKey: "rc522_i2c" },
+  rc522_spi: { yamlKey: "rc522_spi" },
+  rd03d: { yamlKey: "rd03d" },
+  rdm6300: { yamlKey: "rdm6300" },
+  remote_receiver: { yamlKey: "remote_receiver" },
+  remote_transmitter: { yamlKey: "remote_transmitter" },
+  rf_bridge: { yamlKey: "rf_bridge" },
+  rp2040: { yamlKey: "rp2040" },
+  rp2040_ble: { yamlKey: "rp2040_ble" },
+  rtl87xx: { yamlKey: "rtl87xx" },
+  rtttl: { yamlKey: "rtttl" },
+  runtime_stats: { yamlKey: "runtime_stats" },
+  ruuvi_ble: { yamlKey: "ruuvi_ble" },
+  safe_mode: { yamlKey: "safe_mode" },
+  script: { yamlKey: "script" },
+  seeed_mr24hpc1: { yamlKey: "seeed_mr24hpc1" },
+  seeed_mr60bha2: { yamlKey: "seeed_mr60bha2" },
+  seeed_mr60fda2: { yamlKey: "seeed_mr60fda2" },
+  select: { yamlKey: "select" },
+  sensor: { yamlKey: "sensor" },
+  serial_proxy: { yamlKey: "serial_proxy" },
+  servo: { yamlKey: "servo" },
+  sha256: { yamlKey: "sha256" },
+  sim800l: { yamlKey: "sim800l" },
+  sm16716: { yamlKey: "sm16716" },
+  sm2135: { yamlKey: "sm2135" },
+  sm2235: { yamlKey: "sm2235" },
+  sm2335: { yamlKey: "sm2335" },
+  sml: { yamlKey: "sml" },
+  sn74hc165: { yamlKey: "sn74hc165" },
+  sn74hc595: { yamlKey: "sn74hc595" },
+  socket: { yamlKey: "socket" },
+  speaker: { yamlKey: "speaker" },
+  spi: { yamlKey: "spi" },
+  spi_device: { yamlKey: "spi_device" },
+  split_buffer: { yamlKey: "split_buffer" },
+  sprinkler: { yamlKey: "sprinkler" },
+  statsd: { yamlKey: "statsd" },
+  status_led: { yamlKey: "status_led" },
+  stepper: { yamlKey: "stepper" },
+  substitutions: { yamlKey: "substitutions" },
+  sun: { yamlKey: "sun" },
+  sun_gtil2: { yamlKey: "sun_gtil2" },
+  switch: { yamlKey: "switch" },
+  sx126x: { yamlKey: "sx126x" },
+  sx127x: { yamlKey: "sx127x" },
+  sx1509: { yamlKey: "sx1509" },
+  sy6970: { yamlKey: "sy6970" },
+  syslog: { yamlKey: "syslog" },
+  tca9548a: { yamlKey: "tca9548a" },
+  tca9555: { yamlKey: "tca9555" },
+  teleinfo: { yamlKey: "teleinfo" },
+  text: { yamlKey: "text" },
+  text_sensor: { yamlKey: "text_sensor" },
+  time: { yamlKey: "time" },
+  tinyusb: { yamlKey: "tinyusb" },
+  tlc59208f: { yamlKey: "tlc59208f" },
+  tlc5947: { yamlKey: "tlc5947" },
+  tlc5971: { yamlKey: "tlc5971" },
+  tm1651: { yamlKey: "tm1651" },
+  touchscreen: { yamlKey: "touchscreen" },
+  ttp229_bsf: { yamlKey: "ttp229_bsf" },
+  ttp229_lsf: { yamlKey: "ttp229_lsf" },
+  tuya: { yamlKey: "tuya" },
+  uart: { yamlKey: "uart" },
+  udp: { yamlKey: "udp" },
+  update: { yamlKey: "update" },
+  uponor_smatrix: { yamlKey: "uponor_smatrix" },
+  usb_cdc_acm: { yamlKey: "usb_cdc_acm" },
+  usb_host: { yamlKey: "usb_host" },
+  usb_uart: { yamlKey: "usb_uart" },
+  valve: { yamlKey: "valve" },
+  vbus: { yamlKey: "vbus" },
+  voice_assistant: { yamlKey: "voice_assistant" },
+  water_heater: { yamlKey: "water_heater" },
+  web_server: { yamlKey: "web_server" },
+  web_server_base: { yamlKey: "web_server_base" },
+  web_server_idf: { yamlKey: "web_server_idf" },
+  wiegand: { yamlKey: "wiegand" },
+  wifi: { yamlKey: "wifi" },
+  wireguard: { yamlKey: "wireguard" },
+  wk2132_i2c: { yamlKey: "wk2132_i2c" },
+  wk2132_spi: { yamlKey: "wk2132_spi" },
+  wk2168_i2c: { yamlKey: "wk2168_i2c" },
+  wk2168_spi: { yamlKey: "wk2168_spi" },
+  wk2204_i2c: { yamlKey: "wk2204_i2c" },
+  wk2204_spi: { yamlKey: "wk2204_spi" },
+  wk2212_i2c: { yamlKey: "wk2212_i2c" },
+  wk2212_spi: { yamlKey: "wk2212_spi" },
+  wled: { yamlKey: "wled" },
+  xiaomi_ble: { yamlKey: "xiaomi_ble" },
+  xiaomi_rtcgq02lm: { yamlKey: "xiaomi_rtcgq02lm" },
+  xl9535: { yamlKey: "xl9535" },
+  xpt2046: { yamlKey: "xpt2046" },
+  zephyr_ble_server: { yamlKey: "zephyr_ble_server" },
+  zigbee: { yamlKey: "zigbee" },
+  zwave_proxy: { yamlKey: "zwave_proxy" }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ESPCompose,
+  ESPHomeRegistry,
+  Fragment,
+  RefHandle,
+  assertHookCall,
+  createContext,
+  createElement,
+  delay,
+  findInScope,
+  getCurrentComponentName,
+  getCurrentHookIndex,
+  getCurrentHookPath,
+  isRef,
+  logger,
+  registerInScope,
+  render,
+  setCurrentComponentName,
+  setCurrentHookIndex,
+  setCurrentHookPath,
+  toYAML,
+  useContext,
+  useRef,
+  useScript,
+  withContext,
+  withScriptScope
+});