@ulm/core 1.0.0

package/dist/core.js

@@ -0,0 +1,908 @@
+import { setup as L, assign as E, enqueueActions as y, stopChild as T, emit as h, createActor as _ } from "xstate";
+function k(e) {
+  return e?.type === "single";
+}
+function $(e) {
+  return e?.type === "range";
+}
+function b(e) {
+  return e.getSnapshot().context.layerType === "layer";
+}
+function m(e) {
+  return e.getSnapshot().context.layerType === "layerGroup";
+}
+function u(e, t) {
+  return e.find((a) => a.layerActor.id === t);
+}
+function j(e, t) {
+  const a = u(e, t);
+  if (a)
+    return a.layerActor.getSnapshot().context.layerData;
+}
+function D(e, t) {
+  return t.parentId ? O(e, t.parentId) : null;
+}
+function O(e, t) {
+  const a = u(e, t);
+  return !a || !m(a.layerActor) ? null : a.layerActor;
+}
+function Y(e, { layers: t, allowNestedGroupLayers: a }) {
+  return e.layerType === "layerGroup" && e.parentId && !a ? (console.warn("Nested group layers are not allowed."), !1) : t.some((r) => r.layerActor.id === e.layerId) ? (console.warn(`Layer with ID ${e.layerId} already exists. Layer not added.`), !1) : !0;
+}
+function C(e, t) {
+  return e.parentId && !t ? (console.warn("Unable to find valid parent layer. Layer not added."), !1) : !0;
+}
+function M(e) {
+  if (!e)
+    return console.warn("Unable to find layer to remove."), !1;
+  const { layerType: t } = e.layerActor.getSnapshot().context;
+  if (t === "layerGroup") {
+    const { children: a } = e.layerActor.getSnapshot().context;
+    if (a.length > 0)
+      return console.warn("Layer group has children. Not removed."), !1;
+  }
+  return !0;
+}
+function N(e, t) {
+  return e >= 0 && e <= t;
+}
+function g(e, t, a, r) {
+  const i = [...e];
+  if (a !== void 0 && N(a, e.length)) {
+    const o = a > e.length ? e.length : a;
+    i.splice(o, 0, t);
+  } else r === "top" ? i.push(t) : i.unshift(t);
+  return i;
+}
+function S(e, t) {
+  const a = [], r = (i) => {
+    i.forEach((o) => {
+      const l = e.find((n) => n.layerActor.id === o);
+      if (!l)
+        return;
+      a.push(o);
+      const s = l.layerActor.getSnapshot();
+      if (s.context.layerType === "layerGroup") {
+        const n = s.context;
+        r(n.childLayerOrder);
+      }
+    });
+  };
+  return r(t), a;
+}
+function v(e, t) {
+  return e.map((a) => t.find((r) => r.layerActor.id === a)).filter((a) => a !== void 0);
+}
+function z(e, t) {
+  return e.map((a) => t.find((r) => r.id === a)).filter((a) => a !== void 0);
+}
+function P(e, t, a, r, i) {
+  return a ? H(e.layers, t, a, r, i) : U(e.layers, t, e.childLayerOrder, r, i);
+}
+function G(e) {
+  const { parentRef: t } = e.layerActor.getSnapshot().context;
+  t && t.send({ type: "LAYERS.REMOVE_CHILD", id: e.layerActor.id });
+}
+function V(e, t) {
+  return {
+    layers: e.layers.filter((a) => a.layerActor.id !== t),
+    childLayerOrder: e.childLayerOrder.filter((a) => a !== t)
+  };
+}
+function f(e, t) {
+  return e ? e.getSnapshot().context.computedOpacity * t : t;
+}
+function H(e, t, a, r, i) {
+  return a.send({ type: "LAYERS.ADD_CHILD", child: t.layerActor, index: r, position: i }), {
+    layers: [...e, t]
+  };
+}
+function U(e, t, a, r, i) {
+  const o = g(a, t.layerActor.id, r, i);
+  return {
+    layers: [...e, t],
+    childLayerOrder: o
+  };
+}
+function B() {
+  return L({
+    types: {
+      context: {},
+      events: {},
+      input: {}
+    },
+    actions: {
+      "Notify children of visibility change": y(
+        ({ context: e, enqueue: t }, a) => {
+          e.children.forEach((r) => {
+            t.sendTo(r, { type: a.visible ? "PARENT.VISIBLE" : "PARENT.HIDDEN" });
+          });
+        }
+      ),
+      "Notify children of opacity change": y(({ context: e, enqueue: t }) => {
+        e.children.forEach((a) => {
+          t.sendTo(a, {
+            type: "PARENT.OPACITY_CHANGED",
+            opacity: e.computedOpacity
+          });
+        });
+      }),
+      "Notify Parent of visibility change": y(({ context: e, enqueue: t }) => {
+        e.parentRef && t.sendTo(e.parentRef, {
+          type: "CHILD.VISIBLE",
+          layerId: e.layerId
+        });
+      }),
+      "Notify Manager of visibility change": y(
+        ({ context: e, enqueue: t }, a) => {
+          t.sendTo(e.layerManagerRef, {
+            type: "LAYER.UPDATE_VISIBILITY",
+            layerId: e.layerId,
+            visible: a.visible
+          });
+        }
+      ),
+      "Change Layer Data": y(({ context: e, enqueue: t }, a) => {
+        t.assign({ layerData: a.layerData }), t.sendTo(e.layerManagerRef, {
+          type: "LAYER.UPDATE_LAYER_DATA",
+          layerId: e.layerId,
+          layerData: a.layerData
+        });
+      }),
+      "Update Computed Opacity": y(({ context: e, enqueue: t }) => {
+        const a = f(e.parentRef, e.opacity);
+        t.assign({
+          computedOpacity: a
+        }), e.children.forEach((r) => {
+          t.sendTo(r, {
+            type: "PARENT.OPACITY_CHANGED",
+            opacity: a
+          });
+        }), t.sendTo(e.layerManagerRef, {
+          type: "LAYER.UPDATE_OPACITY",
+          layerId: e.layerId,
+          opacity: e.opacity,
+          computedOpacity: e.computedOpacity
+        });
+      }),
+      "Change Layer Opacity": y(
+        ({ context: e, enqueue: t }, a) => {
+          const r = f(e.parentRef, a.opacity);
+          t.assign({
+            opacity: a.opacity,
+            computedOpacity: r
+          }), t.sendTo(e.layerManagerRef, {
+            type: "LAYER.UPDATE_OPACITY",
+            layerId: e.layerId,
+            opacity: a.opacity,
+            computedOpacity: r
+          }), e.children.forEach((i) => {
+            t.sendTo(i, {
+              type: "PARENT.OPACITY_CHANGED",
+              opacity: r
+            });
+          });
+        }
+      ),
+      "Change Layer Time Info": y(
+        ({ context: e, enqueue: t }, a) => {
+          t.assign({ timeInfo: a.timeInfo }), t.sendTo(e.layerManagerRef, {
+            type: "LAYER.UPDATE_TIME_INFO",
+            layerId: e.layerId,
+            timeInfo: a.timeInfo
+          });
+        }
+      ),
+      "Update Children": E(
+        ({ context: e }, t) => {
+          const a = g(
+            e.childLayerOrder,
+            t.child.id,
+            t.index,
+            t.position
+          );
+          return {
+            children: [...e.children, t.child],
+            childLayerOrder: a
+          };
+        }
+      ),
+      "Remove Child": E(({ context: e }, t) => ({
+        children: e.children.filter((a) => a.id !== t.id),
+        childLayerOrder: e.childLayerOrder.filter((a) => a !== t.id)
+      }))
+    }
+  }).createMachine({
+    /** @xstate-layout N4IgpgJg5mDOIC5QBsCGBPMAnA4lg9gK4AOAxAMIASAkgDIAiAdAGrUDK1AQrQKIDaABgC6iUMXywAlgBdJ+AHaiQAD0QBOABwAmRmoCMAgCwa1mjQGYArAHYNAGhDp1jPRu221WgVssDLPgF8AhzRMXAISUloAQQBNHgAlNkZo+noAfSo6ekERJBBxKVkFJVUEa3M1XT0tDWtrY0tDNUMANgcnBCrXd1a9c2tLDT1LNVagkIxsPCIyGPikxgSeAFkAeWYeTJoGXKVCmTlFfLLDY0YK2wFXATcbGw7EEZdzZp99Hz0R14mQUOmIsRGGB5KgAEbISBROKJRj0djRbg8HLCfYSQ4lE6ILT9Ri3NRWNr9ATmcytcyPBADVqMJpfDSteqGLTWPSDX7-cKzYGgiGQRgAN0kUj5pAACtFlgA5AAqjBoaR4Ur2+QOxWOoDK9R01wMagalkqX2slN8hgu+j05Is5NG1g5Uy5JB54MhEEYAAtJBAICDxZKlXLWBwkSqxOj1aVENrdMZWk0NIZrK0tJ5KWcBBavpZGbc9IYbONgn9HTNnRBha6ofNYUrEbwUXlw0UjlGEDjzHiTIS+uYSWSKY5EEnrLTDDU-EMNL5GQ6wmWgRXYFWIBQdkxg1xeGGChHW1j27j8T3iaTyemWXjx3oxq5+t2gsX5PhffB8pyF2iW5jNYgALQ4ro8bmDU5g2imYxaJSXydkYxr9jmwF6HOALciCK5fhiGoqIgYHmrUBbDGy1g+EMlJaK05p0myWikomRhWChTpAuhfLukKIqQphkYHoY5g6ARQzGiRlhkUOVJjGO2bMhYzR+ExC4umxnrer62Fqvuv5dKJjAEa0AgGQYWiGCS6bNIwAwFgY46mDihgKYCjBLhhqp7j+OHtjSJJtHUfTkgMJL2OJpJ6Iw44pgI+pybUWgOdyznKV6PogtxmkeQ0eKvK0vlWqS1hGOm5JhVaN5Wi0Xx8eYj4BEAA */
+    id: "layerGroup",
+    description: "A machine that represents a collection of layers that can be toggled as a group",
+    initial: "disabled",
+    context: ({ input: e }) => {
+      const t = e.opacity ?? 1, a = f(e.parentRef, t);
+      return {
+        layerManagerRef: e.layerManagerRef,
+        layerId: e.layerId,
+        parentRef: e.parentRef,
+        children: [],
+        childLayerOrder: [],
+        layerName: e.layerName,
+        layerType: "layerGroup",
+        listMode: e.listMode ?? "show",
+        timeInfo: e.timeInfo,
+        layerData: e.layerData,
+        opacity: t,
+        computedOpacity: a
+      };
+    },
+    states: {
+      enabled: {
+        initial: "visible",
+        description: "The layer group is enabled",
+        states: {
+          visible: {
+            description: "The layer group should appear visible on the map",
+            entry: [
+              {
+                type: "Notify Parent of visibility change"
+              },
+              {
+                type: "Notify children of visibility change",
+                params: { visible: !0 }
+              },
+              {
+                type: "Notify Manager of visibility change",
+                params: { visible: !0 }
+              }
+            ],
+            exit: [
+              {
+                type: "Notify Manager of visibility change",
+                params: { visible: !1 }
+              },
+              {
+                type: "Notify children of visibility change",
+                params: { visible: !1 }
+              }
+            ],
+            on: {
+              "PARENT.HIDDEN": {
+                target: "hidden"
+              }
+            }
+          },
+          hidden: {
+            description: "The layer group should appear hidden on the map as its parent is hidden",
+            on: {
+              "PARENT.VISIBLE": {
+                target: "visible"
+              }
+            }
+          }
+        },
+        on: {
+          "LAYER.DISABLED": {
+            target: "disabled"
+          }
+        }
+      },
+      disabled: {
+        description: "The layer group is disabled",
+        initial: "hidden",
+        states: {
+          hidden: {
+            description: "The layer group and its children always appear hidden on the map"
+          }
+        },
+        on: {
+          "LAYER.ENABLED": {
+            target: "enabled"
+          },
+          "CHILD.VISIBLE": {
+            target: "enabled"
+          }
+        }
+      }
+    },
+    on: {
+      "PARENT.OPACITY_CHANGED": {
+        actions: "Update Computed Opacity"
+      },
+      "CHILD.VISIBLE": {
+        actions: "Notify Parent of visibility change"
+      },
+      "LAYERS.ADD_CHILD": {
+        actions: [
+          {
+            type: "Update Children",
+            params: ({ event: e }) => e
+          }
+        ]
+      },
+      "LAYERS.REMOVE_CHILD": {
+        actions: [
+          {
+            type: "Remove Child",
+            params: ({ event: e }) => e
+          }
+        ]
+      },
+      "LAYER.SET_LAYER_DATA": {
+        actions: [
+          {
+            type: "Change Layer Data",
+            params: ({ event: e }) => e
+          }
+        ]
+      },
+      "LAYER.SET_OPACITY": {
+        actions: [
+          {
+            type: "Change Layer Opacity",
+            params: ({ event: e }) => e
+          }
+        ]
+      },
+      "LAYER.SET_TIME_INFO": {
+        actions: [
+          {
+            type: "Change Layer Time Info",
+            params: ({ event: e }) => e
+          }
+        ]
+      }
+    }
+  });
+}
+function I(e, t) {
+  return L({
+    types: {
+      context: {},
+      events: {},
+      input: {}
+    },
+    actions: {
+      "Notify Parent that layer is visible": y(({ context: a, enqueue: r }) => {
+        a.parentRef && r.sendTo(a.parentRef, {
+          type: "CHILD.VISIBLE",
+          layerId: a.layerId
+        });
+      }),
+      "Notify Manager of visibility change": y(
+        ({ context: a, enqueue: r }, i) => r.sendTo(a.layerManagerRef, {
+          type: "LAYER.UPDATE_VISIBILITY",
+          layerId: a.layerId,
+          visible: i.visible
+        })
+      ),
+      "Update Computed Opacity": y(({ context: a, enqueue: r }, i) => {
+        const o = i.opacity * a.opacity;
+        r.assign({
+          computedOpacity: o
+        }), r.sendTo(a.layerManagerRef, {
+          type: "LAYER.UPDATE_OPACITY",
+          layerId: a.layerId,
+          opacity: a.opacity,
+          computedOpacity: o
+        });
+      }),
+      "Change Layer Opacity": y(
+        ({ context: a, enqueue: r }, i) => {
+          const o = f(a.parentRef, i.opacity);
+          r.assign({
+            opacity: i.opacity,
+            computedOpacity: o
+          }), r.sendTo(a.layerManagerRef, {
+            type: "LAYER.UPDATE_OPACITY",
+            layerId: a.layerId,
+            opacity: i.opacity,
+            computedOpacity: o
+          });
+        }
+      ),
+      "Change Layer Time Info": y(
+        ({ context: a, enqueue: r }, i) => {
+          r.assign({
+            timeInfo: i.timeInfo
+          }), r.sendTo(a.layerManagerRef, {
+            type: "LAYER.UPDATE_TIME_INFO",
+            layerId: a.layerId,
+            timeInfo: i.timeInfo
+          });
+        }
+      ),
+      "Change Layer Data": y(({ context: a, enqueue: r }, i) => {
+        r.assign({ layerData: i.layerData }), r.sendTo(a.layerManagerRef, {
+          type: "LAYER.UPDATE_LAYER_DATA",
+          layerId: a.layerId,
+          layerData: i.layerData
+        });
+      })
+    }
+  }).createMachine({
+    id: "layer",
+    description: "A machine that represents a layer on the map.",
+    context: ({ input: a }) => {
+      const r = a.opacity ?? 1, i = f(a.parentRef, r);
+      return {
+        layerManagerRef: a.layerManagerRef,
+        parentRef: a.parentRef,
+        layerId: a.layerId,
+        layerName: a.layerName,
+        listMode: a.listMode ?? "show",
+        opacity: r,
+        computedOpacity: i,
+        layerType: "layer",
+        timeInfo: a.timeInfo,
+        layerData: a.layerData
+      };
+    },
+    initial: e,
+    states: {
+      enabled: {
+        initial: t,
+        description: "The layer is enabled",
+        states: {
+          visible: {
+            description: "The layer should appear visible on the map",
+            entry: [
+              {
+                type: "Notify Parent that layer is visible"
+              },
+              {
+                type: "Notify Manager of visibility change",
+                params: {
+                  visible: !0
+                }
+              }
+            ],
+            exit: [
+              {
+                type: "Notify Manager of visibility change",
+                params: {
+                  visible: !1
+                }
+              }
+            ],
+            on: {
+              "PARENT.HIDDEN": {
+                target: "hidden"
+              }
+            }
+          },
+          hidden: {
+            description: "The layer should appear hidden on the map as its parent is hidden",
+            on: {
+              "PARENT.VISIBLE": {
+                target: "visible"
+              }
+            }
+          }
+        },
+        on: {
+          "LAYER.DISABLED": {
+            target: "disabled"
+          }
+        }
+      },
+      disabled: {
+        description: "The layer is disabled",
+        initial: "hidden",
+        states: {
+          hidden: {
+            description: "The layer should always appear hidden on the map"
+          }
+        },
+        on: {
+          "LAYER.ENABLED": {
+            target: "enabled.visible"
+          }
+        }
+      }
+    },
+    on: {
+      "PARENT.OPACITY_CHANGED": {
+        actions: [
+          {
+            type: "Update Computed Opacity",
+            params: ({ event: a }) => a
+          }
+        ]
+      },
+      "LAYER.SET_OPACITY": {
+        actions: [
+          {
+            type: "Change Layer Opacity",
+            params: ({ event: a }) => a
+          }
+        ]
+      },
+      "LAYER.SET_TIME_INFO": {
+        actions: [
+          {
+            type: "Change Layer Time Info",
+            params: ({ event: a }) => a
+          }
+        ]
+      },
+      "LAYER.SET_LAYER_DATA": {
+        actions: [
+          {
+            type: "Change Layer Data",
+            params: ({ event: a }) => a
+          }
+        ]
+      }
+    }
+  });
+}
+function w() {
+  return L({
+    types: {
+      context: {},
+      events: {},
+      emitted: {},
+      input: {}
+    },
+    actors: {
+      layerMachineEnabledVisible: I("enabled", "visible"),
+      layerMachineEnabledHidden: I("enabled", "hidden"),
+      layerMachineDisabled: I("disabled", "hidden"),
+      layerGroupMachine: B()
+    },
+    actions: {
+      "Add new layer": y(({ enqueue: e, context: t, self: a }, r) => {
+        const { layerConfig: i, index: o, visible: l, enabled: s, position: n } = r, d = D(t.layers, i);
+        if (!C(i, d))
+          return;
+        function R(c, p) {
+          return p || c && !d ? "layerMachineEnabledVisible" : c && d && d.getSnapshot().value && d.getSnapshot().matches({ disabled: "hidden" }) ? "layerMachineEnabledHidden" : "layerMachineDisabled";
+        }
+        e.assign(({ spawn: c }) => {
+          let p;
+          if (i.layerType === "layerGroup") {
+            const A = c("layerGroupMachine", {
+              id: i.layerId,
+              input: {
+                layerManagerRef: a,
+                parentRef: d,
+                ...i
+              }
+            });
+            l && A.send({ type: "LAYER.ENABLED" }), p = {
+              type: "layerGroup",
+              layerActor: A
+            };
+          } else
+            p = {
+              type: "layer",
+              layerActor: c(R(s ?? !1, l ?? !1), {
+                id: i.layerId,
+                input: {
+                  layerManagerRef: a,
+                  parentRef: d,
+                  ...i
+                }
+              })
+            };
+          return P(t, p, d, o, n);
+        }), e.emit({
+          type: "LAYER.ADDED",
+          layerId: i.layerId,
+          visible: l ?? !1
+        });
+      }),
+      "Remove layer": y(({ enqueue: e, context: t }, a) => {
+        const { layerId: r } = a, i = u(t.layers, r);
+        !i || !M(i) || (G(i), e.stopChild(r), e.assign(() => V(t, r)), e.emit({ type: "LAYER.REMOVED", layerId: r }));
+      }),
+      "Emit update layer order": h(({ context: e }) => ({
+        type: "LAYER.ORDER_CHANGED",
+        layerOrder: S(e.layers, e.childLayerOrder)
+      })),
+      // Reset actions
+      "Reset layer manager": E(({ context: e }) => (e.layers.forEach((t) => {
+        T(t.layerActor.id);
+      }), {
+        layers: [],
+        childLayerOrder: []
+      }))
+    },
+    guards: {
+      isValidLayerConfig: ({ context: e }, t) => Y(t.layerConfig, e)
+    }
+  }).createMachine({
+    id: "layerManager",
+    context: ({ input: e }) => ({
+      layers: [],
+      childLayerOrder: [],
+      allowNestedGroupLayers: e.allowNestedGroupLayers
+    }),
+    on: {
+      "LAYER.UPDATE_VISIBILITY": {
+        actions: h(({ event: e }) => ({
+          type: "LAYER.VISIBILITY_CHANGED",
+          layerId: e.layerId,
+          visible: e.visible
+        }))
+      },
+      "LAYER.UPDATE_OPACITY": {
+        actions: [
+          h(({ event: e }) => ({
+            type: "LAYER.OPACITY_CHANGED",
+            layerId: e.layerId,
+            opacity: e.opacity,
+            computedOpacity: e.computedOpacity
+          }))
+        ]
+      },
+      "LAYER.UPDATE_TIME_INFO": {
+        actions: h(({ event: e }) => ({
+          type: "LAYER.TIME_INFO_CHANGED",
+          layerId: e.layerId,
+          timeInfo: e.timeInfo
+        }))
+      },
+      "LAYER.UPDATE_LAYER_DATA": {
+        actions: h(({ event: e }) => ({
+          type: "LAYER.LAYER_DATA_CHANGED",
+          layerId: e.layerId,
+          layerData: e.layerData
+        }))
+      },
+      "LAYER.ADD": {
+        guard: {
+          type: "isValidLayerConfig",
+          params: ({ event: e }) => e.params
+        },
+        actions: [
+          {
+            type: "Add new layer",
+            params: ({ event: e }) => e.params
+          },
+          {
+            type: "Emit update layer order"
+          }
+        ]
+      },
+      "LAYER.REMOVE": {
+        actions: [
+          {
+            type: "Remove layer",
+            params: ({ event: e }) => e
+          },
+          {
+            type: "Emit update layer order"
+          }
+        ]
+      },
+      RESET: {
+        actions: ["Reset layer manager"]
+      }
+    }
+  });
+}
+class J {
+  _actor;
+  _options;
+  _adapter = null;
+  /** Cleanup functions for each active XState actor event subscription. */
+  _subscriptions = [];
+  _destroyed = !1;
+  constructor(t = {}) {
+    this._options = t, this._actor = _(w(), {
+      input: { allowNestedGroupLayers: this._options.allowNestedGroupLayers ?? !1 }
+    }), this.start();
+  }
+  // --------------------------------------------------------------------------
+  // State
+  // --------------------------------------------------------------------------
+  /**
+   * Escape hatch for `@xstate/react` integration (e.g. `useSelector`).
+   * Prefer the typed methods on this class for all other use cases.
+   */
+  get actor() {
+    return this._actor;
+  }
+  /** `true` while the underlying XState actor is running (i.e. not yet stopped). */
+  get isReady() {
+    return this._actor.getSnapshot().status === "active";
+  }
+  /** `true` after {@link destroy} has been called. The instance cannot be reused once destroyed. */
+  get destroyed() {
+    return this._destroyed;
+  }
+  /** The current top-level layers in their display order. */
+  get layers() {
+    const { childLayerOrder: t, layers: a } = this._actor.getSnapshot().context;
+    return v(t, a);
+  }
+  /** Returns the managed item for `id`, or `undefined` if it does not exist. */
+  getLayer(t) {
+    const { layers: a } = this._actor.getSnapshot().context;
+    return u(a, t);
+  }
+  // --------------------------------------------------------------------------
+  // Lifecycle
+  // --------------------------------------------------------------------------
+  /** Starts the XState actor, wires event subscriptions, and registers any pending adapter. */
+  start() {
+    this._actor.start(), this._wireSubscriptions(), this._adapter && this._registerAdapter(this._adapter);
+  }
+  /** Alias for {@link destroy}. */
+  stop() {
+    this.destroy();
+  }
+  /** Resets layer state, unregisters the adapter, cancels all subscriptions, and stops the actor. */
+  destroy() {
+    this._cleanupSubscriptions(), this._adapter?.unregister?.(), this.reset(), this._actor.stop(), this._destroyed = !0;
+  }
+  /** Removes all layers and groups, returning the manager to its initial empty state. */
+  reset() {
+    this._actor.send({ type: "RESET" });
+  }
+  // --------------------------------------------------------------------------
+  // Adapter
+  // --------------------------------------------------------------------------
+  /**
+   * Attach or replace the adapter at any time.
+   * Pass `null` to detach the current adapter.
+   */
+  setAdapter(t) {
+    this._adapter?.unregister?.(), this._adapter = t, t && this.isReady && this._registerAdapter(t);
+  }
+  // --------------------------------------------------------------------------
+  // Layer operations
+  // --------------------------------------------------------------------------
+  /** Adds a single layer to the manager. */
+  addLayer(t) {
+    this._actor.send({ type: "LAYER.ADD", params: t });
+  }
+  /** Adds a layer group to the manager. */
+  addGroup(t) {
+    this._actor.send({ type: "LAYER.ADD", params: t });
+  }
+  /** Removes the layer or group with the given `layerId`. */
+  removeLayer(t) {
+    this._actor.send({ type: "LAYER.REMOVE", layerId: t });
+  }
+  /** Shows or hides the layer with the given `layerId`. */
+  setVisibility(t, a) {
+    const r = this.getLayer(t);
+    r && r.layerActor.send(a ? { type: "LAYER.ENABLED" } : { type: "LAYER.DISABLED" });
+  }
+  /** Alias for {@link setVisibility}. */
+  setEnabled(t, a) {
+    this.setVisibility(t, a);
+  }
+  /** Sets the opacity (0–1) for the layer with the given `layerId`. */
+  setOpacity(t, a) {
+    const r = this.getLayer(t);
+    r && r.layerActor.send({ type: "LAYER.SET_OPACITY", opacity: a });
+  }
+  /** Sets the time info for the layer with the given `layerId`. */
+  setTimeInfo(t, a) {
+    const r = this.getLayer(t);
+    r && r.layerActor.send({ type: "LAYER.SET_TIME_INFO", timeInfo: a });
+  }
+  /** Replaces the `layerData` payload for the layer or group with the given `layerId`. */
+  updateLayerData(t, a) {
+    const r = this.getLayer(t);
+    r && r.layerActor.send({ type: "LAYER.SET_LAYER_DATA", layerData: a });
+  }
+  // --------------------------------------------------------------------------
+  // Private helpers
+  // --------------------------------------------------------------------------
+  /** Subscribes to machine-emitted events and forwards them to the adapter and options callbacks. */
+  _wireSubscriptions() {
+    const t = this._actor.on("LAYER.ADDED", (s) => {
+      const n = this._toManagedLayerInfo(s.layerId, s.visible);
+      n && (this._adapter?.onLayerAdded?.(n), this._options.onLayerAdded?.(n));
+    });
+    this._subscriptions.push(() => t.unsubscribe());
+    const a = this._actor.on("LAYER.REMOVED", (s) => {
+      this._adapter?.onLayerRemoved?.(s.layerId), this._options.onLayerRemoved?.(s.layerId);
+    });
+    this._subscriptions.push(() => a.unsubscribe());
+    const r = this._actor.on("LAYER.VISIBILITY_CHANGED", (s) => {
+      const n = this._toManagedLayerInfo(s.layerId, s.visible);
+      n && (this._adapter?.onVisibilityChanged?.(n, s.visible), this._options.onVisibilityChanged?.(n, s.visible));
+    });
+    this._subscriptions.push(() => r.unsubscribe());
+    const i = this._actor.on("LAYER.OPACITY_CHANGED", (s) => {
+      const n = this._toManagedLayerInfo(s.layerId);
+      n && (this._adapter?.onOpacityChanged?.(n, s.computedOpacity), this._options.onOpacityChanged?.(n, s.computedOpacity));
+    });
+    this._subscriptions.push(() => i.unsubscribe());
+    const o = this._actor.on("LAYER.TIME_INFO_CHANGED", (s) => {
+      const n = this._toManagedLayerInfo(s.layerId);
+      n && (this._adapter?.onTimeInfoChanged?.(n, s.timeInfo), this._options.onTimeInfoChanged?.(n, s.timeInfo));
+    });
+    this._subscriptions.push(() => o.unsubscribe());
+    const l = this._actor.on("LAYER.LAYER_DATA_CHANGED", (s) => {
+      const n = this._toManagedLayerInfo(s.layerId);
+      n && this._adapter?.onLayerDataChanged?.(n);
+    });
+    this._subscriptions.push(() => l.unsubscribe());
+  }
+  _cleanupSubscriptions() {
+    for (const t of this._subscriptions)
+      t();
+    this._subscriptions.length = 0;
+  }
+  _registerAdapter(t) {
+    const a = {
+      getSnapshot: () => this.layers,
+      getLayer: (r) => this.getLayer(r)
+    };
+    t.register?.(this, a);
+  }
+  /**
+   * Converts an internal XState actor context into the stable
+   * {@link ManagedLayerInfo} shape exposed to adapters and option callbacks.
+   * The `isLayerMachine` branch is required for TypeScript to narrow `ctx`
+   * to the correct discriminated union member.
+   */
+  _toManagedLayerInfo(t, a) {
+    const { layers: r } = this._actor.getSnapshot().context, i = u(r, t);
+    if (!i)
+      return null;
+    const o = i.layerActor.getSnapshot(), l = o.matches("enabled"), s = a ?? o.matches({ enabled: "visible" });
+    if (b(i.layerActor)) {
+      const n = i.layerActor.getSnapshot().context;
+      return {
+        layerId: n.layerId,
+        layerName: n.layerName,
+        layerType: "layer",
+        layerData: n.layerData,
+        opacity: n.opacity,
+        computedOpacity: n.computedOpacity,
+        enabled: l,
+        visible: s,
+        timeInfo: n.timeInfo,
+        listMode: n.listMode,
+        parentId: n.parentRef?.getSnapshot().context.layerId ?? null
+      };
+    } else {
+      const n = i.layerActor.getSnapshot().context;
+      return {
+        layerId: n.layerId,
+        layerName: n.layerName,
+        layerType: "layerGroup",
+        layerData: n.layerData,
+        opacity: n.opacity,
+        computedOpacity: n.computedOpacity,
+        enabled: l,
+        visible: s,
+        timeInfo: n.timeInfo,
+        listMode: n.listMode,
+        parentId: n.parentRef?.getSnapshot().context.layerId ?? null
+      };
+    }
+  }
+}
+export {
+  J as LayerManager,
+  f as calculateComputedOpacity,
+  M as canRemoveLayer,
+  G as cleanupLayerReferences,
+  w as createLayerManagerMachine,
+  u as findManagedLayerById,
+  D as findParentActor,
+  O as findParentLayerGroupActor,
+  S as getFlatLayerOrder,
+  j as getLayerDataFromLayerId,
+  z as getLayerGroupChildrenInOrder,
+  v as getTopLevelLayersInOrder,
+  P as getUpdatedLayerStructure,
+  V as getUpdatedLayerStructureAfterRemoval,
+  m as isLayerGroupMachine,
+  b as isLayerMachine,
+  $ as isRangeTimeInfo,
+  k as isSingleTimeInfo,
+  Y as isValidLayerConfig,
+  N as isValidLayerIndex,
+  C as isValidParentRef,
+  B as layerGroupMachine,
+  I as layerMachine,
+  g as updateLayerOrder
+};