foldkit-primitives 0.15.4 → 0.16.0

package/dist/events/pointer.js

@@ -0,0 +1,28 @@
+import { Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+// src/events/pointer.ts
+/**
+* Pointer position as an entry — not a bundle, because the parent owns what
+* it keeps (a cursor, a drag anchor, hover state): this reports moves, and
+* the parent stores what matters. Element-scoped pointer needs are Mounts,
+* not this window-level entry.
+*/
+const PointerMessage = defineMessageUnion({ Moved: {
+	x: Schema.Number,
+	y: Schema.Number
+} });
+/**
+* Pointer moves on the window. Without a window the stream is empty instead
+* of throwing. Lift with `Subscription.persistentEntry`, mapping into the
+* parent's Message.
+*/
+const pointerEvents = () => {
+	if (typeof window === "undefined") return Stream.empty;
+	return Stream.fromEventListener(window, "pointermove").pipe(Stream.map((event) => PointerMessage.Moved({
+		x: event.clientX,
+		y: event.clientY
+	})));
+};
+export { PointerMessage, pointerEvents };
+
+//# sourceMappingURL=pointer.js.map

package/dist/events/pointer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointer.js","names":[],"sources":["../../src/events/pointer.ts"],"sourcesContent":["/**\n * Pointer position as an entry — not a bundle, because the parent owns what\n * it keeps (a cursor, a drag anchor, hover state): this reports moves, and\n * the parent stores what matters. Element-scoped pointer needs are Mounts,\n * not this window-level entry.\n */\nimport { Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\n\nexport const PointerMessage = defineMessageUnion({\n  Moved: { x: Schema.Number, y: Schema.Number },\n})\nexport type PointerMessage = typeof PointerMessage.Type\n\n/**\n * Pointer moves on the window. Without a window the stream is empty instead\n * of throwing. Lift with `Subscription.persistentEntry`, mapping into the\n * parent's Message.\n */\nexport const pointerEvents = (): Stream.Stream<PointerMessage> => {\n  if (typeof window === 'undefined') return Stream.empty\n  return Stream.fromEventListener<PointerEvent>(window, 'pointermove').pipe(\n    Stream.map(event => PointerMessage.Moved({ x: event.clientX, y: event.clientY })),\n  )\n}\n"],"mappings":";;;;;;;;;AASA,MAAa,iBAAiB,mBAAmB,EAC/C,OAAO;CAAE,GAAG,OAAO;CAAQ,GAAG,OAAO;AAAO,EAC9C,CAAC;;;;;;AAQD,MAAa,sBAAqD;CAChE,IAAI,OAAO,WAAW,aAAa,OAAO,OAAO;CACjD,OAAO,OAAO,kBAAgC,QAAQ,aAAa,CAAC,CAAC,KACnE,OAAO,KAAI,UAAS,eAAe,MAAM;EAAE,GAAG,MAAM;EAAS,GAAG,MAAM;CAAQ,CAAC,CAAC,CAClF;AACF"}

package/dist/events/scroll.d.ts

@@ -0,0 +1,16 @@
+import { Schema, Stream } from "effect";
+export declare const ScrollMessage: import("foldkit/message").MessageUnion<{
+  readonly Scrolled: {
+    x: Schema.Number;
+    y: Schema.Number;
+  };
+}>;
+export type ScrollMessage = typeof ScrollMessage.Type;
+/**
+ * Scrolls on the window, in the capture phase so container scrolls (which
+ * do not bubble) report too. Without a window the stream is empty instead
+ * of throwing. Lift with `Subscription.persistentEntry`, mapping into the
+ * parent's Message.
+ */
+export declare const scrollEvents: () => Stream.Stream<ScrollMessage>;
+//# sourceMappingURL=scroll.d.ts.map

package/dist/events/scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll.d.ts","names":[],"sources":["../../src/events/scroll.ts"],"mappings":";qBASa,yCAAa;;IACZ,GAAC,OAAA;IAAiB,GAAC,OAAA;;;YAErB,uBAAuB,cAAc;;;;;;;qBAQpC,oBAAmB,OAAO,OAAO"}

package/dist/events/scroll.js

@@ -0,0 +1,29 @@
+import { Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+// src/events/scroll.ts
+/**
+* Window scroll position as an entry — not a bundle, because the parent
+* owns what it keeps (a stuck header, a back-to-top gate, restore-on-back):
+* this reports positions, and the parent stores what matters.
+* Element-scoped scrolling needs a Mount, not this window-level entry.
+*/
+const ScrollMessage = defineMessageUnion({ Scrolled: {
+	x: Schema.Number,
+	y: Schema.Number
+} });
+/**
+* Scrolls on the window, in the capture phase so container scrolls (which
+* do not bubble) report too. Without a window the stream is empty instead
+* of throwing. Lift with `Subscription.persistentEntry`, mapping into the
+* parent's Message.
+*/
+const scrollEvents = () => {
+	if (typeof window === "undefined") return Stream.empty;
+	return Stream.fromEventListener(window, "scroll", { capture: true }).pipe(Stream.map(() => ScrollMessage.Scrolled({
+		x: window.scrollX,
+		y: window.scrollY
+	})));
+};
+export { ScrollMessage, scrollEvents };
+
+//# sourceMappingURL=scroll.js.map

package/dist/events/scroll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll.js","names":[],"sources":["../../src/events/scroll.ts"],"sourcesContent":["/**\n * Window scroll position as an entry — not a bundle, because the parent\n * owns what it keeps (a stuck header, a back-to-top gate, restore-on-back):\n * this reports positions, and the parent stores what matters.\n * Element-scoped scrolling needs a Mount, not this window-level entry.\n */\nimport { Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\n\nexport const ScrollMessage = defineMessageUnion({\n  Scrolled: { x: Schema.Number, y: Schema.Number },\n})\nexport type ScrollMessage = typeof ScrollMessage.Type\n\n/**\n * Scrolls on the window, in the capture phase so container scrolls (which\n * do not bubble) report too. Without a window the stream is empty instead\n * of throwing. Lift with `Subscription.persistentEntry`, mapping into the\n * parent's Message.\n */\nexport const scrollEvents = (): Stream.Stream<ScrollMessage> => {\n  if (typeof window === 'undefined') return Stream.empty\n  return Stream.fromEventListener(window, 'scroll', { capture: true }).pipe(\n    Stream.map(() => ScrollMessage.Scrolled({ x: window.scrollX, y: window.scrollY })),\n  )\n}\n"],"mappings":";;;;;;;;;AASA,MAAa,gBAAgB,mBAAmB,EAC9C,UAAU;CAAE,GAAG,OAAO;CAAQ,GAAG,OAAO;AAAO,EACjD,CAAC;;;;;;;AASD,MAAa,qBAAmD;CAC9D,IAAI,OAAO,WAAW,aAAa,OAAO,OAAO;CACjD,OAAO,OAAO,kBAAkB,QAAQ,UAAU,EAAE,SAAS,KAAK,CAAC,CAAC,CAAC,KACnE,OAAO,UAAU,cAAc,SAAS;EAAE,GAAG,OAAO;EAAS,GAAG,OAAO;CAAQ,CAAC,CAAC,CACnF;AACF"}

package/dist/events/visibility.d.ts

@@ -0,0 +1,25 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+export declare const VisibilityModel: Schema.Struct<{
+  readonly visible: Schema.Boolean;
+}>;
+export type VisibilityModel = typeof VisibilityModel.Type;
+export declare const VisibilityMessage: import("foldkit/message").MessageUnion<{
+  readonly Changed: {
+    visible: Schema.Boolean;
+  };
+}>;
+export type VisibilityMessage = typeof VisibilityMessage.Type;
+/**
+ * Page visibility as a bundle: `visible` in the Model, read from the
+ * document at startup and kept current by `visibilitychange`. A hidden page
+ * is the application's cue to pause polling, animations, and realtime
+ * streams; the decision stays in application `update`, not here.
+ */
+export declare const Visibility: Bundle.Bundle<"Visibility", void, {
+  readonly visible: boolean;
+}, {
+  readonly _tag: "Changed";
+  readonly visible: boolean;
+}, never, never, never, void, {}, {}>;
+//# sourceMappingURL=visibility.d.ts.map

package/dist/events/visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibility.d.ts","names":[],"sources":["../../src/events/visibility.ts"],"mappings":";;qBAKa,iBAAe,OAAA;;;YAChB,yBAAyB,gBAAgB;qBAExC,6CAAiB;;IAAmC,SAAO,OAAA;;;YAC5D,2BAA2B,kBAAkB;;;;;;;qBAuB5C,YAAU,OAAA"}

package/dist/events/visibility.js

@@ -0,0 +1,28 @@
+import { Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import * as Subscription from "foldkit/subscription";
+import { Bundle } from "foldkit-bundle";
+// src/events/visibility.ts
+const VisibilityModel = Schema.Struct({ visible: Schema.Boolean });
+const VisibilityMessage = defineMessageUnion({ Changed: { visible: Schema.Boolean } });
+const isVisible = () => typeof document === "undefined" || document.visibilityState !== "hidden";
+const visibilityStream = () => {
+	if (typeof document === "undefined" || typeof document.addEventListener !== "function") return Stream.empty;
+	return Stream.concat(Stream.make(VisibilityMessage.Changed({ visible: isVisible() })), Stream.fromEventListener(document, "visibilitychange").pipe(Stream.map(() => VisibilityMessage.Changed({ visible: isVisible() }))));
+};
+/**
+* Page visibility as a bundle: `visible` in the Model, read from the
+* document at startup and kept current by `visibilitychange`. A hidden page
+* is the application's cue to pause polling, animations, and realtime
+* streams; the decision stays in application `update`, not here.
+*/
+const Visibility = Bundle.make("Visibility", {
+	Model: VisibilityModel,
+	Message: VisibilityMessage,
+	init: () => ({ model: { visible: isVisible() } }),
+	update: (model, message) => message.visible === model.visible ? { model } : { model: { visible: message.visible } },
+	subscriptions: () => Subscription.make()(() => ({ changes: Subscription.persistentEntry(visibilityStream()) }))
+});
+export { Visibility, VisibilityMessage, VisibilityModel };
+
+//# sourceMappingURL=visibility.js.map

package/dist/events/visibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibility.js","names":[],"sources":["../../src/events/visibility.ts"],"sourcesContent":["import { Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as Subscription from 'foldkit/subscription'\nimport { Bundle } from 'foldkit-bundle'\n\nexport const VisibilityModel = Schema.Struct({ visible: Schema.Boolean })\nexport type VisibilityModel = typeof VisibilityModel.Type\n\nexport const VisibilityMessage = defineMessageUnion({ Changed: { visible: Schema.Boolean } })\nexport type VisibilityMessage = typeof VisibilityMessage.Type\n\nconst isVisible = (): boolean =>\n  typeof document === 'undefined' || document.visibilityState !== 'hidden'\n\nconst visibilityStream = (): Stream.Stream<VisibilityMessage> => {\n  if (typeof document === 'undefined' || typeof document.addEventListener !== 'function') {\n    return Stream.empty\n  }\n  return Stream.concat(\n    Stream.make(VisibilityMessage.Changed({ visible: isVisible() })),\n    Stream.fromEventListener(document, 'visibilitychange').pipe(\n      Stream.map(() => VisibilityMessage.Changed({ visible: isVisible() })),\n    ),\n  )\n}\n\n/**\n * Page visibility as a bundle: `visible` in the Model, read from the\n * document at startup and kept current by `visibilitychange`. A hidden page\n * is the application's cue to pause polling, animations, and realtime\n * streams; the decision stays in application `update`, not here.\n */\nexport const Visibility = Bundle.make('Visibility', {\n  Model: VisibilityModel,\n  Message: VisibilityMessage,\n  // No document (SSR): assume visible; the stream corrects on subscribe.\n  init: () => ({ model: { visible: isVisible() } }),\n  // The stream opens with the state `init` already read.\n  update: (model, message) =>\n    message.visible === model.visible ? { model } : { model: { visible: message.visible } },\n  subscriptions: (): Subscription.Subscriptions<VisibilityModel, VisibilityMessage> =>\n    Subscription.make<VisibilityModel, VisibilityMessage>()(() => ({\n      changes: Subscription.persistentEntry(visibilityStream()),\n    })),\n})\n"],"mappings":";;;;;AAKA,MAAa,kBAAkB,OAAO,OAAO,EAAE,SAAS,OAAO,QAAQ,CAAC;AAGxE,MAAa,oBAAoB,mBAAmB,EAAE,SAAS,EAAE,SAAS,OAAO,QAAQ,EAAE,CAAC;AAG5F,MAAM,kBACJ,OAAO,aAAa,eAAe,SAAS,oBAAoB;AAElE,MAAM,yBAA2D;CAC/D,IAAI,OAAO,aAAa,eAAe,OAAO,SAAS,qBAAqB,YAC1E,OAAO,OAAO;CAEhB,OAAO,OAAO,OACZ,OAAO,KAAK,kBAAkB,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC,CAAC,GAC/D,OAAO,kBAAkB,UAAU,kBAAkB,CAAC,CAAC,KACrD,OAAO,UAAU,kBAAkB,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC,CAAC,CACtE,CACF;AACF;;;;;;;AAQA,MAAa,aAAa,OAAO,KAAK,cAAc;CAClD,OAAO;CACP,SAAS;CAET,aAAa,EAAE,OAAO,EAAE,SAAS,UAAU,EAAE,EAAE;CAE/C,SAAS,OAAO,YACd,QAAQ,YAAY,MAAM,UAAU,EAAE,MAAM,IAAI,EAAE,OAAO,EAAE,SAAS,QAAQ,QAAQ,EAAE;CACxF,qBACE,aAAa,KAAyC,CAAC,QAAQ,EAC7D,SAAS,aAAa,gBAAgB,iBAAiB,CAAC,EAC1D,EAAE;AACN,CAAC"}

package/dist/events/window-size.d.ts

@@ -0,0 +1,30 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+export declare const WindowSizeModel: Schema.Struct<{
+  readonly width: Schema.Number;
+  readonly height: Schema.Number;
+}>;
+export type WindowSizeModel = typeof WindowSizeModel.Type;
+export declare const WindowSizeMessage: import("foldkit/message").MessageUnion<{
+  readonly Changed: {
+    width: Schema.Number;
+    height: Schema.Number;
+  };
+}>;
+export type WindowSizeMessage = typeof WindowSizeMessage.Type;
+/**
+ * Window size as a bundle: `{ width, height }` in the Model, read from the
+ * window at startup and kept current by one `resize` listener. Breakpoints
+ * owns its own listener and derives names; place this one when views need
+ * the raw pixels. Placing both doubles resize listeners — pick the one the
+ * view reads.
+ */
+export declare const WindowSize: Bundle.Bundle<"WindowSize", void, {
+  readonly width: number;
+  readonly height: number;
+}, {
+  readonly _tag: "Changed";
+  readonly width: number;
+  readonly height: number;
+}, never, never, never, void, {}, {}>;
+//# sourceMappingURL=window-size.d.ts.map

package/dist/events/window-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window-size.d.ts","names":[],"sources":["../../src/events/window-size.ts"],"mappings":";;qBAMa,iBAAe,OAAA;;;;YAChB,yBAAyB,gBAAgB;qBAExC,6CAAiB;;IACjB,OAAK,OAAA;IAAiB,QAAM,OAAA;;;YAE7B,2BAA2B,kBAAkB;;;;;;;;qBA0C5C,YAAU,OAAA"}

package/dist/events/window-size.js

@@ -0,0 +1,63 @@
+import { Effect, Queue, Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import * as Subscription from "foldkit/subscription";
+import { Bundle } from "foldkit-bundle";
+import { unlessSame } from "../internal.js";
+// src/events/window-size.ts
+const WindowSizeModel = Schema.Struct({
+	width: Schema.Number,
+	height: Schema.Number
+});
+const WindowSizeMessage = defineMessageUnion({ Changed: {
+	width: Schema.Number,
+	height: Schema.Number
+} });
+const readSize = () => ({
+	width: window.innerWidth,
+	height: window.innerHeight
+});
+const sizeStream = () => {
+	if (typeof window === "undefined" || typeof window.addEventListener !== "function") return Stream.empty;
+	return Stream.unwrap(Effect.gen(function* () {
+		const queue = yield* Queue.unbounded();
+		const onResize = () => {
+			const size = readSize();
+			Effect.runFork(Queue.offer(queue, WindowSizeMessage.Changed({
+				width: size.width,
+				height: size.height
+			})));
+		};
+		window.addEventListener("resize", onResize);
+		yield* Effect.addFinalizer(() => Effect.sync(() => {
+			window.removeEventListener("resize", onResize);
+		}));
+		const size = readSize();
+		return Stream.concat(Stream.make(WindowSizeMessage.Changed({
+			width: size.width,
+			height: size.height
+		})), Stream.fromQueue(queue));
+	}));
+};
+/**
+* Window size as a bundle: `{ width, height }` in the Model, read from the
+* window at startup and kept current by one `resize` listener. Breakpoints
+* owns its own listener and derives names; place this one when views need
+* the raw pixels. Placing both doubles resize listeners — pick the one the
+* view reads.
+*/
+const WindowSize = Bundle.make("WindowSize", {
+	Model: WindowSizeModel,
+	Message: WindowSizeMessage,
+	init: () => ({ model: {
+		width: 0,
+		height: 0
+	} }),
+	update: (model, message) => ({ model: unlessSame(model, {
+		width: message.width,
+		height: message.height
+	}) }),
+	subscriptions: () => Subscription.make()(() => ({ changes: Subscription.persistentEntry(sizeStream()) }))
+});
+export { WindowSize, WindowSizeMessage, WindowSizeModel };
+
+//# sourceMappingURL=window-size.js.map

package/dist/events/window-size.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"window-size.js","names":[],"sources":["../../src/events/window-size.ts"],"sourcesContent":["import { Effect, Queue, Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as Subscription from 'foldkit/subscription'\nimport { Bundle } from 'foldkit-bundle'\nimport { unlessSame } from '../internal.js'\n\nexport const WindowSizeModel = Schema.Struct({ width: Schema.Number, height: Schema.Number })\nexport type WindowSizeModel = typeof WindowSizeModel.Type\n\nexport const WindowSizeMessage = defineMessageUnion({\n  Changed: { width: Schema.Number, height: Schema.Number },\n})\nexport type WindowSizeMessage = typeof WindowSizeMessage.Type\n\nconst readSize = (): { readonly width: number; readonly height: number } => ({\n  width: window.innerWidth,\n  height: window.innerHeight,\n})\n\nconst sizeStream = (): Stream.Stream<WindowSizeMessage> => {\n  if (typeof window === 'undefined' || typeof window.addEventListener !== 'function') {\n    return Stream.empty\n  }\n  return Stream.unwrap(\n    Effect.gen(function* () {\n      const queue = yield* Queue.unbounded<WindowSizeMessage>()\n      const onResize = () => {\n        const size = readSize()\n        Effect.runFork(\n          Queue.offer(queue, WindowSizeMessage.Changed({ width: size.width, height: size.height })),\n        )\n      }\n      window.addEventListener('resize', onResize)\n      yield* Effect.addFinalizer(() =>\n        Effect.sync(() => {\n          window.removeEventListener('resize', onResize)\n        }),\n      )\n      const size = readSize()\n      return Stream.concat(\n        Stream.make(WindowSizeMessage.Changed({ width: size.width, height: size.height })),\n        Stream.fromQueue(queue),\n      )\n    }),\n  )\n}\n\n/**\n * Window size as a bundle: `{ width, height }` in the Model, read from the\n * window at startup and kept current by one `resize` listener. Breakpoints\n * owns its own listener and derives names; place this one when views need\n * the raw pixels. Placing both doubles resize listeners — pick the one the\n * view reads.\n */\nexport const WindowSize = Bundle.make('WindowSize', {\n  Model: WindowSizeModel,\n  Message: WindowSizeMessage,\n  init: () => ({ model: { width: 0, height: 0 } }),\n  update: (model, message) => ({\n    model: unlessSame(model, { width: message.width, height: message.height }),\n  }),\n  subscriptions: (): Subscription.Subscriptions<WindowSizeModel, WindowSizeMessage> =>\n    Subscription.make<WindowSizeModel, WindowSizeMessage>()(() => ({\n      changes: Subscription.persistentEntry(sizeStream()),\n    })),\n})\n"],"mappings":";;;;;;AAMA,MAAa,kBAAkB,OAAO,OAAO;CAAE,OAAO,OAAO;CAAQ,QAAQ,OAAO;AAAO,CAAC;AAG5F,MAAa,oBAAoB,mBAAmB,EAClD,SAAS;CAAE,OAAO,OAAO;CAAQ,QAAQ,OAAO;AAAO,EACzD,CAAC;AAGD,MAAM,kBAAuE;CAC3E,OAAO,OAAO;CACd,QAAQ,OAAO;AACjB;AAEA,MAAM,mBAAqD;CACzD,IAAI,OAAO,WAAW,eAAe,OAAO,OAAO,qBAAqB,YACtE,OAAO,OAAO;CAEhB,OAAO,OAAO,OACZ,OAAO,IAAI,aAAa;EACtB,MAAM,QAAQ,OAAO,MAAM,UAA6B;EACxD,MAAM,iBAAiB;GACrB,MAAM,OAAO,SAAS;GACtB,OAAO,QACL,MAAM,MAAM,OAAO,kBAAkB,QAAQ;IAAE,OAAO,KAAK;IAAO,QAAQ,KAAK;GAAO,CAAC,CAAC,CAC1F;EACF;EACA,OAAO,iBAAiB,UAAU,QAAQ;EAC1C,OAAO,OAAO,mBACZ,OAAO,WAAW;GAChB,OAAO,oBAAoB,UAAU,QAAQ;EAC/C,CAAC,CACH;EACA,MAAM,OAAO,SAAS;EACtB,OAAO,OAAO,OACZ,OAAO,KAAK,kBAAkB,QAAQ;GAAE,OAAO,KAAK;GAAO,QAAQ,KAAK;EAAO,CAAC,CAAC,GACjF,OAAO,UAAU,KAAK,CACxB;CACF,CAAC,CACH;AACF;;;;;;;;AASA,MAAa,aAAa,OAAO,KAAK,cAAc;CAClD,OAAO;CACP,SAAS;CACT,aAAa,EAAE,OAAO;EAAE,OAAO;EAAG,QAAQ;CAAE,EAAE;CAC9C,SAAS,OAAO,aAAa,EAC3B,OAAO,WAAW,OAAO;EAAE,OAAO,QAAQ;EAAO,QAAQ,QAAQ;CAAO,CAAC,EAC3E;CACA,qBACE,aAAa,KAAyC,CAAC,QAAQ,EAC7D,SAAS,aAAa,gBAAgB,WAAW,CAAC,EACpD,EAAE;AACN,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./dom/index.js";
+export * from "./device/index.js";
+export * from "./events/index.js";
+export * from "./media/index.js";
+export * from "./motion/index.js";
+export * from "./net/index.js";
+export * from "./observers/index.js";
+export * from "./state/index.js";
+export * from "./time/index.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./dom/index.js";
+export * from "./device/index.js";
+export * from "./events/index.js";
+export * from "./media/index.js";
+export * from "./motion/index.js";
+export * from "./net/index.js";
+export * from "./observers/index.js";
+export * from "./state/index.js";
+export * from "./time/index.js";
+export {};

package/dist/interaction/bundle-behavior.d.ts

@@ -0,0 +1,37 @@
+import { Bundle, Declared } from "foldkit-bundle";
+import { MountAction } from "foldkit/mount";
+import { NamedBehavior, SlotAttributes, SlotItem, SlotRequirements } from "foldkit-mixins";
+import { HtmlBuilder } from "foldkit/html";
+type BundleOf<D extends Declared<any, any>> = D extends Declared<infer B, any> ? B : never;
+/** The Bundle's Model, which the parent's `Input` must hold at `declared.field`. */
+export type BundleModelOf<D extends Declared<any, any>> = Bundle.BundleParts<BundleOf<D>>['Model'];
+/** The Bundle's Message, which `send` wraps for the parent. */
+export type BundleMessageOf<D extends Declared<any, any>> = Bundle.BundleParts<BundleOf<D>>['Message'];
+export interface BundleSlotOptions<D extends Declared<any, any>, Input, ParentMessage> {
+  readonly requires?: SlotRequirements;
+  readonly attributes?: (context: {
+    readonly input: Input;
+    readonly h: HtmlBuilder<ParentMessage>;
+    readonly item?: SlotItem;
+    /** The Bundle's Message as the parent's: what a handler the Behavior writes takes. */
+    readonly send: (message: BundleMessageOf<D>) => ParentMessage;
+  }) => SlotAttributes<ParentMessage>;
+  /** The Bundle's events, mounted on this slot and wrapped for the parent. */
+  readonly events?: MountAction<BundleMessageOf<D>, any>;
+}
+export type BundleBehaviorSpec<D extends Declared<any, any>, Input, ParentMessage> = Readonly<Record<string, BundleSlotOptions<D, Input, ParentMessage>>>;
+/**
+ * `fromBundle(declared)(slots)<Input, ParentMessage>(spec)` — a Behavior over
+ * `declared`, with every `events` mount and every `send` mapped through the
+ * placement's wrapper. `Input` must hold the Bundle's Model at the declared
+ * field, so attributes read the placed slice; the parent's `Message` includes
+ * the declared wrapper cases, so nothing can be sent outside it.
+ */
+export declare const fromBundle: <D extends Declared<any, any>>(declared: D) => <Slots>(slots: Slots) => <Input extends { readonly [K in D['field']]: BundleModelOf<D>; }, ParentMessage>(spec: BundleBehaviorSpec<D, Input, ParentMessage>, options?: {
+  readonly name?: string;
+}) => NamedBehavior<Slots, Input, ParentMessage>;
+export declare const BundleBehavior: {
+  readonly fromBundle: typeof fromBundle;
+};
+export {};
+//# sourceMappingURL=bundle-behavior.d.ts.map

package/dist/interaction/bundle-behavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-behavior.d.ts","names":[],"sources":["../../src/interaction/bundle-behavior.ts"],"mappings":";;;;KA+BK,SAAS,UAAU,sBAAsB,UAAU,eAAe,UAAU;;YAGrE,cAAc,UAAU,sBAAsB,OAAO,YAAY,SAAS;;YAG1E,gBAAgB,UAAU,sBAAsB,OAAO,YACjE,SAAS;iBAGM,kBAAkB,UAAU,oBAAoB,OAAO;WAC7D,WAAW;WACX,cAAc;aACZ,OAAO;aACP,GAAG,YAAY;aACf,OAAO;;aAEP,OAAO,SAAS,gBAAgB,OAAO;QAC5C,eAAe;;WAEZ,SAAS,YAAY,gBAAgB;;YAGpC,mBAAmB,UAAU,oBAAoB,OAAO,iBAAiB,SACnF,eAAe,kBAAkB,GAAG,OAAO;;;;;;;;qBAUhC,aACV,UAAU,oBAAkB,UAAY,OACxC,OAAK,OAAS,WACd,0BAA0B,KAAK,aAAa,cAAc,OAAM,eAAa,MACtE,mBAAmB,GAAG,OAAO,gBAAc;WAC5B;MACpB,cAAc,OAAO,OAAO;qBAiCpB"}

package/dist/interaction/bundle-behavior.js

@@ -0,0 +1,34 @@
+import * as Mount from "foldkit/mount";
+import { Behavior } from "foldkit-mixins";
+// src/interaction/bundle-behavior.ts
+/**
+* `fromBundle(declared)(slots)<Input, ParentMessage>(spec)` — a Behavior over
+* `declared`, with every `events` mount and every `send` mapped through the
+* placement's wrapper. `Input` must hold the Bundle's Model at the declared
+* field, so attributes read the placed slice; the parent's `Message` includes
+* the declared wrapper cases, so nothing can be sent outside it.
+*/
+const fromBundle = (declared) => (slots) => (spec, options) => {
+	const send = (message) => declared.wrapper.make(message);
+	const built = Object.create(null);
+	for (const [name, slot] of Object.entries(spec)) {
+		if (slot === void 0) continue;
+		const { requires, attributes, events } = slot;
+		if (requires === void 0 && attributes === void 0 && events === void 0) continue;
+		built[name] = {
+			...requires === void 0 ? {} : { requires },
+			...attributes === void 0 ? {} : { attributes: (context) => attributes({
+				input: context.input,
+				h: context.h,
+				...context.item === void 0 ? {} : { item: context.item },
+				send
+			}) },
+			...events === void 0 ? {} : { mount: () => Mount.mapMessage(events, send) }
+		};
+	}
+	return Behavior.forSlots(slots)(built, options);
+};
+const BundleBehavior = { fromBundle };
+export { BundleBehavior, fromBundle };
+
+//# sourceMappingURL=bundle-behavior.js.map

package/dist/interaction/bundle-behavior.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-behavior.js","names":[],"sources":["../../src/interaction/bundle-behavior.ts"],"sourcesContent":["/**\n * The mixin half of a Bundle: a Behavior whose slots are wired to the\n * Bundle's Messages through its `Declared` placement.\n *\n * The Bundle owns the Model, its Message union and the transition; a parent\n * declares and places it (`Bundle.declare(...).at(...)`); this Behavior writes\n * the element's attributes from the placed slice and mounts the Bundle's\n * events, wrapping each Message with the placement's `wrapper` into the\n * parent's universe. A Behavior still owns no state, and a Message still has\n * one update: this is a bridge, not a second runtime.\n *\n * `attributes` receives `send`, the same wrap, for a handler it writes itself\n * (`h.OnClick(send(Message.Activated({ id })))`). `events` receives the\n * Bundle's own Mount (a `Mount.defineStream`), and the helper supplies the\n * mapping, so a caller never repeats `Mount.mapMessage(events, wrapper.make)`.\n */\nimport type { HtmlBuilder } from 'foldkit/html'\nimport type { MountAction } from 'foldkit/mount'\nimport * as Mount from 'foldkit/mount'\nimport type { Bundle, Declared } from 'foldkit-bundle'\nimport {\n  Behavior,\n  type BehaviorSlotOptions,\n  type NamedBehavior,\n  type SlotAttributes,\n  type SlotItem,\n  type SlotRequirements,\n} from 'foldkit-mixins'\n\n// `any` for the bundle and the field so a behavior's own generic `Field`\n// (`Declared<typeof bundle, Field>`) is accepted; the parts stay inferred.\ntype BundleOf<D extends Declared<any, any>> = D extends Declared<infer B, any> ? B : never\n\n/** The Bundle's Model, which the parent's `Input` must hold at `declared.field`. */\nexport type BundleModelOf<D extends Declared<any, any>> = Bundle.BundleParts<BundleOf<D>>['Model']\n\n/** The Bundle's Message, which `send` wraps for the parent. */\nexport type BundleMessageOf<D extends Declared<any, any>> = Bundle.BundleParts<\n  BundleOf<D>\n>['Message']\n\nexport interface BundleSlotOptions<D extends Declared<any, any>, Input, ParentMessage> {\n  readonly requires?: SlotRequirements\n  readonly attributes?: (context: {\n    readonly input: Input\n    readonly h: HtmlBuilder<ParentMessage>\n    readonly item?: SlotItem\n    /** The Bundle's Message as the parent's: what a handler the Behavior writes takes. */\n    readonly send: (message: BundleMessageOf<D>) => ParentMessage\n  }) => SlotAttributes<ParentMessage>\n  /** The Bundle's events, mounted on this slot and wrapped for the parent. */\n  readonly events?: MountAction<BundleMessageOf<D>, any>\n}\n\nexport type BundleBehaviorSpec<D extends Declared<any, any>, Input, ParentMessage> = Readonly<\n  Record<string, BundleSlotOptions<D, Input, ParentMessage>>\n>\n\n/**\n * `fromBundle(declared)(slots)<Input, ParentMessage>(spec)` — a Behavior over\n * `declared`, with every `events` mount and every `send` mapped through the\n * placement's wrapper. `Input` must hold the Bundle's Model at the declared\n * field, so attributes read the placed slice; the parent's `Message` includes\n * the declared wrapper cases, so nothing can be sent outside it.\n */\nexport const fromBundle =\n  <D extends Declared<any, any>>(declared: D) =>\n  <Slots>(slots: Slots) =>\n  <Input extends { readonly [K in D['field']]: BundleModelOf<D> }, ParentMessage>(\n    spec: BundleBehaviorSpec<D, Input, ParentMessage>,\n    options?: { readonly name?: string },\n  ): NamedBehavior<Slots, Input, ParentMessage> => {\n    const send = (message: BundleMessageOf<D>): ParentMessage =>\n      declared.wrapper.make(message) as unknown as ParentMessage\n    const built: Record<string, BehaviorSlotOptions<Input, ParentMessage>> = Object.create(null)\n    for (const [name, slot] of Object.entries(\n      spec as Record<string, BundleSlotOptions<D, Input, ParentMessage> | undefined>,\n    )) {\n      if (slot === undefined) continue\n      const { requires, attributes, events } = slot\n      if (requires === undefined && attributes === undefined && events === undefined) continue\n      built[name] = {\n        ...(requires === undefined ? {} : { requires }),\n        ...(attributes === undefined\n          ? {}\n          : {\n              attributes: context =>\n                attributes({\n                  input: context.input as Input,\n                  h: context.h,\n                  ...(context.item === undefined ? {} : { item: context.item }),\n                  send,\n                }),\n            }),\n        ...(events === undefined ? {} : { mount: () => Mount.mapMessage(events, send) }),\n      }\n    }\n    return Behavior.forSlots(slots)<Input, ParentMessage>(\n      // Built slot by slot from the same contract `forSlots` validates.\n      built as unknown as Behavior.BehaviorSpec<Slots, Input, ParentMessage>,\n      options,\n    )\n  }\n\nexport const BundleBehavior = { fromBundle } as const\n"],"mappings":";;;;;;;;;;AAiEA,MAAa,cACoB,cACvB,WAEN,MACA,YAC+C;CAC/C,MAAM,QAAQ,YACZ,SAAS,QAAQ,KAAK,OAAO;CAC/B,MAAM,QAAmE,OAAO,OAAO,IAAI;CAC3F,KAAK,MAAM,CAAC,MAAM,SAAS,OAAO,QAChC,IACF,GAAG;EACD,IAAI,SAAS,KAAA,GAAW;EACxB,MAAM,EAAE,UAAU,YAAY,WAAW;EACzC,IAAI,aAAa,KAAA,KAAa,eAAe,KAAA,KAAa,WAAW,KAAA,GAAW;EAChF,MAAM,QAAQ;GACZ,GAAI,aAAa,KAAA,IAAY,CAAC,IAAI,EAAE,SAAS;GAC7C,GAAI,eAAe,KAAA,IACf,CAAC,IACD,EACE,aAAY,YACV,WAAW;IACT,OAAO,QAAQ;IACf,GAAG,QAAQ;IACX,GAAI,QAAQ,SAAS,KAAA,IAAY,CAAC,IAAI,EAAE,MAAM,QAAQ,KAAK;IAC3D;GACF,CAAC,EACL;GACJ,GAAI,WAAW,KAAA,IAAY,CAAC,IAAI,EAAE,aAAa,MAAM,WAAW,QAAQ,IAAI,EAAE;EAChF;CACF;CACA,OAAO,SAAS,SAAS,KAAK,CAAC,CAE7B,OACA,OACF;AACF;AAEF,MAAa,iBAAiB,EAAE,WAAW"}

package/dist/interaction/dismiss-layer.d.ts

@@ -0,0 +1,100 @@
+import { Schema } from "effect";
+import { Bundle, Declared } from "foldkit-bundle";
+import { Behavior } from "foldkit-mixins";
+export declare const LAYER_ATTRIBUTE = "data-foldkit-plus-layer";
+export declare const TRIGGER_ATTRIBUTE = "data-foldkit-plus-layer-trigger";
+/** An open layer as the document showed it: bottom to top is DOM order. */
+export declare const Layer: Schema.Struct<{
+  readonly id: Schema.String;
+  /** Dismiss on a press outside it. */
+  readonly outside: Schema.Boolean;
+  /** Dismiss on Escape when topmost. */
+  readonly escape: Schema.Boolean;
+}>;
+export type Layer = typeof Layer.Type;
+export declare const Model: Schema.Struct<{
+  /** The open layers at the last event, bottom to top. */
+  readonly layers: Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    /** Dismiss on a press outside it. */
+    readonly outside: Schema.Boolean;
+    /** Dismiss on Escape when topmost. */
+    readonly escape: Schema.Boolean;
+  }>>;
+}>;
+export type Model = typeof Model.Type;
+export declare const Message: import("foldkit/message").MessageUnion<{
+  /** A pointer went down; `inside` are the layers whose element or trigger was on the event's path. */
+  readonly PressedAt: {
+    layers: Schema.$Array<Schema.Struct<{
+      readonly id: Schema.String;
+      /** Dismiss on a press outside it. */
+      readonly outside: Schema.Boolean;
+      /** Dismiss on Escape when topmost. */
+      readonly escape: Schema.Boolean;
+    }>>;
+    inside: Schema.$Array<Schema.String>;
+  };
+  readonly PressedEscape: {
+    layers: Schema.$Array<Schema.Struct<{
+      readonly id: Schema.String;
+      /** Dismiss on a press outside it. */
+      readonly outside: Schema.Boolean;
+      /** Dismiss on Escape when topmost. */
+      readonly escape: Schema.Boolean;
+    }>>;
+  };
+}>;
+export type Message = typeof Message.Type;
+export declare const Dismiss: Schema.TaggedStruct<"Dismiss", {
+  readonly ids: Schema.$Array<Schema.String>;
+}>;
+export type Dismiss = typeof Dismiss.Type;
+/** Which layers a press inside `inside` dismisses: every layer above the topmost one hit, or all when none was. */
+export declare const toDismiss: (layers: ReadonlyArray<Layer>, inside: ReadonlyArray<string>) => ReadonlyArray<string>;
+export declare const bundle: Bundle.Bundle<"DismissLayer", void, {
+  readonly layers: readonly {
+    readonly id: string;
+    readonly outside: boolean;
+    readonly escape: boolean;
+  }[];
+}, {
+  readonly _tag: "PressedAt";
+  readonly layers: readonly {
+    readonly id: string;
+    readonly outside: boolean;
+    readonly escape: boolean;
+  }[];
+  readonly inside: readonly string[];
+} | {
+  readonly _tag: "PressedEscape";
+  readonly layers: readonly {
+    readonly id: string;
+    readonly outside: boolean;
+    readonly escape: boolean;
+  }[];
+}, {
+  readonly _tag: "Dismiss";
+  readonly ids: readonly string[];
+}, never, never, void, {}, {}>;
+/** The layer ids whose element or trigger is on the event's composed path. */
+export declare const layersOnPath: (path: ReadonlyArray<EventTarget>) => ReadonlyArray<string>;
+export interface BehaviorOptions<Input, Slots> {
+  /** The layer's root, rendered only while the layer is open. */
+  readonly layer: keyof Slots & string;
+  /** The element that opens the layer, so a press on it is inside. */
+  readonly trigger?: keyof Slots & string;
+  readonly id: (input: Input) => string;
+  /** Dismiss on a press outside. Default `true`. */
+  readonly outsidePress?: boolean;
+  /** Dismiss on Escape when topmost. Default `true`. */
+  readonly escape?: boolean;
+}
+/**
+ * Marks the layer's container and trigger for the placed stack. The layer
+ * takes part only while its element is rendered, so an `open` flag in the
+ * parent Model is the whole lifecycle. Not for an element with `popover`,
+ * which the browser dismisses itself.
+ */
+export declare const behavior: <Field extends string>(_declared: Declared<typeof bundle, Field>) => <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+//# sourceMappingURL=dismiss-layer.d.ts.map

package/dist/interaction/dismiss-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dismiss-layer.d.ts","names":[],"sources":["../../src/interaction/dismiss-layer.ts"],"mappings":";;;qBAmBa;qBACA;;qBAKA,OAAK,OAAA;;;;;;;YAON,eAAe,MAAM;qBAEpB,OAAK,OAAA;;;;;;;;;;YAIN,eAAe,MAAM;qBAEpB,mCAAO;;;IAEL,QAAM,OAAA,OAAA,OAAA;;;;;;;IAAuB,QAAM,OAAA,OAAA,OAAA;;;IAC/B,QAAM,OAAA,OAAA,OAAA;;;;;;;;;YAEb,iBAAiB,QAAQ;qBAExB,SAAO,OAAA;;;YACR,iBAAiB,QAAQ;;qBAGxB,YAAS,QACZ,cAAc,QAAM,QACpB,0BACP;qBAsBU,QAAM,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqCN,eAAY,MAAU,cAAc,iBAAe;iBA6C/C,gBAAgB,OAAO;;WAE7B,aAAa;;WAEb,gBAAgB;WAChB,KAAK,OAAO;;WAEZ;;WAEA;;;;;;;;qBASE,WACV,sBAAoB,WAAa,gBAAgB,QAAQ,YACzD,OAAK,OAAS,WACd,OAAO,eAAa,SACV,gBAAgB,OAAO,WAC/B,SAAS,cAAc,OAAO,OAAO"}

package/dist/interaction/dismiss-layer.js

@@ -0,0 +1,140 @@
+import { Effect, Queue, Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import * as Subscription from "foldkit/subscription";
+import { Bundle } from "foldkit-bundle";
+import { Behavior, Capability } from "foldkit-mixins";
+// src/interaction/dismiss-layer.ts
+/**
+* Dismissable layers: Escape closes the topmost open layer, a pointer press
+* outside closes the layers it is outside of. One Bundle, placed once, owns
+* the document listeners; each layer's Behavior marks its container (and its
+* trigger) with data attributes. The stack is the DOM order of the marked
+* elements at the moment of the event, so a layer opening or closing needs no
+* registration. A press inside a parent layer is outside its children, so the
+* parent stays and the children go; a press on a layer's trigger counts as
+* inside it, so a trigger never dismisses and reopens in one click. What a
+* dismissal does is the placement's `onOut`.
+*/
+const LAYER_ATTRIBUTE = "data-foldkit-plus-layer";
+const TRIGGER_ATTRIBUTE = "data-foldkit-plus-layer-trigger";
+const OUTSIDE_ATTRIBUTE = "data-foldkit-plus-layer-outside";
+const ESCAPE_ATTRIBUTE = "data-foldkit-plus-layer-escape";
+/** An open layer as the document showed it: bottom to top is DOM order. */
+const Layer = Schema.Struct({
+	id: Schema.String,
+	/** Dismiss on a press outside it. */
+	outside: Schema.Boolean,
+	/** Dismiss on Escape when topmost. */
+	escape: Schema.Boolean
+});
+const Model = Schema.Struct({ 
+/** The open layers at the last event, bottom to top. */
+layers: Schema.Array(Layer) });
+const Message = defineMessageUnion({
+	/** A pointer went down; `inside` are the layers whose element or trigger was on the event's path. */
+	PressedAt: {
+		layers: Schema.Array(Layer),
+		inside: Schema.Array(Schema.String)
+	},
+	PressedEscape: { layers: Schema.Array(Layer) }
+});
+const Dismiss = Schema.TaggedStruct("Dismiss", { ids: Schema.Array(Schema.String) });
+/** Which layers a press inside `inside` dismisses: every layer above the topmost one hit, or all when none was. */
+const toDismiss = (layers, inside) => {
+	let topmostHit = -1;
+	layers.forEach((layer, index) => {
+		if (inside.includes(layer.id)) topmostHit = index;
+	});
+	return layers.slice(topmostHit + 1).filter((layer) => layer.outside).map((layer) => layer.id);
+};
+const sameLayers = (a, b) => a.length === b.length && a.every((layer, index) => layer.id === b[index].id && layer.outside === b[index].outside && layer.escape === b[index].escape);
+const bundle = Bundle.make("DismissLayer", {
+	Model,
+	Message,
+	init: () => ({ model: { layers: [] } }),
+	update: (model, message) => {
+		const next = sameLayers(model.layers, message.layers) ? model : { layers: message.layers };
+		return Message.match(message, {
+			PressedAt: ({ layers, inside }) => {
+				const ids = toDismiss(layers, inside);
+				return ids.length === 0 ? { model: next } : {
+					model: next,
+					outMessage: Dismiss.make({ ids })
+				};
+			},
+			PressedEscape: ({ layers }) => {
+				const top = layers[layers.length - 1];
+				return top !== void 0 && top.escape ? {
+					model: next,
+					outMessage: Dismiss.make({ ids: [top.id] })
+				} : { model: next };
+			}
+		});
+	},
+	subscriptions: () => Subscription.make()(() => ({ document: Subscription.persistentEntry(documentEvents()) }))
+});
+const openLayers = (root) => Array.from(root.querySelectorAll(`[${LAYER_ATTRIBUTE}]`)).map((element) => ({
+	id: element.getAttribute("data-foldkit-plus-layer") ?? "",
+	outside: element.getAttribute(OUTSIDE_ATTRIBUTE) !== "false",
+	escape: element.getAttribute(ESCAPE_ATTRIBUTE) !== "false"
+}));
+/** The layer ids whose element or trigger is on the event's composed path. */
+const layersOnPath = (path) => {
+	const ids = [];
+	for (const target of path) {
+		if (!(target instanceof Element)) continue;
+		const id = target.getAttribute("data-foldkit-plus-layer") ?? target.getAttribute("data-foldkit-plus-layer-trigger");
+		if (id !== null && !ids.includes(id)) ids.push(id);
+	}
+	return ids;
+};
+/**
+* The facts are read inside the listener, not after: `composedPath()` is
+* empty once dispatch has finished, and the open layers must be the ones the
+* press saw, not the ones a later render left.
+*/
+const documentEvents = () => {
+	if (typeof document === "undefined") return Stream.empty;
+	return Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+		const onPointerDown = (event) => Queue.offerUnsafe(queue, Message.PressedAt({
+			layers: openLayers(document),
+			inside: layersOnPath(event.composedPath())
+		}));
+		const onKeyDown = (event) => {
+			if (event.key !== "Escape") return;
+			Queue.offerUnsafe(queue, Message.PressedEscape({ layers: openLayers(document) }));
+		};
+		document.addEventListener("pointerdown", onPointerDown, { capture: true });
+		document.addEventListener("keydown", onKeyDown, { capture: true });
+		return {
+			onPointerDown,
+			onKeyDown
+		};
+	}), ({ onPointerDown, onKeyDown }) => Effect.sync(() => {
+		document.removeEventListener("pointerdown", onPointerDown, { capture: true });
+		document.removeEventListener("keydown", onKeyDown, { capture: true });
+	})));
+};
+/**
+* Marks the layer's container and trigger for the placed stack. The layer
+* takes part only while its element is rendered, so an `open` flag in the
+* parent Model is the whole lifecycle. Not for an element with `popover`,
+* which the browser dismisses itself.
+*/
+const behavior = (_declared) => (slots) => (options) => Behavior.forSlots(slots)({
+	[options.layer]: Behavior.slot({
+		requires: { capability: Capability.Container },
+		attributes: ({ input, h }) => [
+			h.Attribute(LAYER_ATTRIBUTE, options.id(input)),
+			...options.outsidePress === false ? [h.Attribute(OUTSIDE_ATTRIBUTE, "false")] : [],
+			...options.escape === false ? [h.Attribute(ESCAPE_ATTRIBUTE, "false")] : []
+		]
+	}),
+	...options.trigger === void 0 ? {} : { [options.trigger]: Behavior.slot({
+		requires: { capability: Capability.Interactive },
+		attributes: ({ input, h }) => [h.Attribute(TRIGGER_ATTRIBUTE, options.id(input))]
+	}) }
+}, { name: "DismissLayer" });
+export { Dismiss, LAYER_ATTRIBUTE, Layer, Message, Model, TRIGGER_ATTRIBUTE, behavior, bundle, layersOnPath, toDismiss };
+
+//# sourceMappingURL=dismiss-layer.js.map