live_svelte

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);

// js/live_svelte/index.js
var live_svelte_exports = {};
__export(live_svelte_exports, {
  getHooks: () => getHooks,
  getRender: () => getRender
});
module.exports = __toCommonJS(live_svelte_exports);

// js/live_svelte/utils.js
function normalizeComponents(components) {
  if (!Array.isArray(components.default) || !Array.isArray(components.filenames)) return components;
  const normalized = {};
  for (const [index, module2] of components.default.entries()) {
    const Component = module2.default;
    const name = components.filenames[index].replace("../svelte/", "").replace(".svelte", "");
    normalized[name] = Component;
  }
  return normalized;
}
function decodeB64ToUTF8(b64) {
  const chars = Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
  return new TextDecoder().decode(chars);
}

// js/live_svelte/render.js
var import_server = require("svelte/server");
var import_svelte = require("svelte");
function getRender(components) {
  components = normalizeComponents(components);
  return function r(name, props, slots) {
    const snippets = Object.fromEntries(
      Object.entries(slots).map(([slotName, v]) => {
        const snippet = (0, import_svelte.createRawSnippet)((name2) => {
          return {
            render: () => v
          };
        });
        if (slotName === "default") return ["children", snippet];
        else return [slotName, snippet];
      })
    );
    return (0, import_server.render)(components[name], { props: { ...props, ...snippets } });
  };
}

// js/live_svelte/hooks.svelte.js
var $ = __toESM(require("svelte/internal/client"));
var import_svelte2 = require("svelte");
function getAttributeJson(ref, attributeName) {
  const data = ref.el.getAttribute(attributeName);
  return data ? JSON.parse(data) : {};
}
function getSlots(ref) {
  let snippets = {};
  for (const slotName in getAttributeJson(ref, "data-slots")) {
    const base64 = getAttributeJson(ref, "data-slots")[slotName];
    const element = document.createElement("div");
    element.innerHTML = decodeB64ToUTF8(base64).trim();
    const snippet = (0, import_svelte2.createRawSnippet)((name) => {
      return { render: () => element.outerHTML };
    });
    if (slotName === "default") snippets["children"] = snippet;
    else snippets[slotName] = snippet;
  }
  return snippets;
}
function getLiveJsonProps(ref) {
  const json = getAttributeJson(ref, "data-live-json");
  if (!Array.isArray(json)) return json;
  const liveJsonData = {};
  for (const liveJsonVariable of json) {
    const data = window[liveJsonVariable];
    if (data) liveJsonData[liveJsonVariable] = data;
  }
  return liveJsonData;
}
function getProps(ref) {
  return {
    ...getAttributeJson(ref, "data-props"),
    ...getLiveJsonProps(ref),
    ...getSlots(ref),
    live: ref
  };
}
function update_state(ref) {
  const newProps = getProps(ref);
  for (const key in newProps) {
    ref._instance.state[key] = newProps[key];
  }
}
function getHooks(components) {
  components = normalizeComponents(components);
  const SvelteHook = {
    mounted() {
      let state = $.proxy(getProps(this));
      const componentName = this.el.getAttribute("data-name");
      if (!componentName) throw new Error("Component name must be provided");
      const Component = components[componentName];
      if (!Component) throw new Error(`Unable to find ${componentName} component.`);
      for (const liveJsonElement of Object.keys(getAttributeJson(this, "data-live-json"))) {
        window.addEventListener(`${liveJsonElement}_initialized`, (_event) => update_state(this), false);
        window.addEventListener(`${liveJsonElement}_patched`, (_event) => update_state(this), false);
      }
      if (!this.el.hasAttribute("data-ssr")) {
        this.el.innerHTML = "";
      }
      const hydrateOrMount = this.el.hasAttribute("data-ssr") ? import_svelte2.hydrate : import_svelte2.mount;
      this._instance = hydrateOrMount(Component, { target: this.el, props: state });
      this._instance.state = state;
    },
    updated() {
      update_state(this);
    },
    destroyed() {
      if (this._instance) window.addEventListener("phx:page-loading-stop", () => (0, import_svelte2.unmount)(this._instance), { once: true });
    }
  };
  return { SvelteHook };
}
//# sourceMappingURL=live_svelte.cjs.js.map