@oimdb/browser 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,74 @@
-# Temporary Holding Version
+# @oimdb/browser
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Browser state as OIMDB single slots: the network, window focus, document visibility and the location.
+An effect, a computed or a React hook reads them like any other slot, and the browser listener exists
+only while something is subscribed.
+
+```bash
+npm install @oimdb/browser @oimdb/core
+```
+
+## A factory returns a single slot service
+
+Each factory returns an `OIMSingleSlotService`: build a store slot on your `db` and read the slot through
+the service, as with any single.
+
+```ts setup
+import { OIMDB, OIMEffectService } from '@oimdb/core';
+import {
+    createOIMBrowserOnlineSingleSlotService,
+    createOIMBrowserFocusSingleSlotService,
+    createOIMBrowserVisibilitySingleSlotService,
+    createOIMBrowserLocationSingleSlotService,
+} from '@oimdb/browser';
+
+const db = new OIMDB();
+const refetchStale = (): void => undefined;
+```
+
+```ts
+const onlineService = createOIMBrowserOnlineSingleSlotService();
+const online = onlineService.createStoreSlot(db);
+const onlineSlot = onlineService.getSingleSlot(online);
+
+OIMEffectService.INSTANCE.createEffect(db, () => {
+    if (onlineSlot.entity?.isOnline === true) refetchStale();
+}, [onlineSlot]);
+```
+
+In React, `useOIMSingleEntity(onlineService, online)` from `@oimdb/react` reads the same entity.
+
+| Factory | Entity | Listens to |
+|---|---|---|
+| `createOIMBrowserOnlineSingleSlotService` | `TOIMBrowserOnlineEntity` `{ isOnline }` | `online`, `offline` on `window` |
+| `createOIMBrowserFocusSingleSlotService` | `TOIMBrowserFocusEntity` `{ isFocused }` | `focus`, `blur` on `window` |
+| `createOIMBrowserVisibilitySingleSlotService` | `TOIMBrowserVisibilityEntity` `{ isVisible }` | `visibilitychange` on `document` |
+| `createOIMBrowserLocationSingleSlotService` | `TOIMBrowserLocationEntity` `{ href, pathname, search, hash }` | `currententrychange` on `navigation`; without the Navigation API, `popstate` and `hashchange` on `window` |
+
+Every factory takes an optional `defaults` (an `OIMDefaults` of `@oimdb/core`), passed on to the
+single slot service and its entity content service.
+
+## When the browser is listened to
+
+The service is built with a slot subscription listener. When the slot gets its first subscriber, the
+listener adds its browser listener and writes the current value; when the last subscriber goes, it
+takes the browser listener off. A subscriber reached through a computed counts too: an effect on a
+computed that reads the slot is enough.
+
+A write that would land during a flush is made right after that flush ends, because a channel refuses
+writes for the whole of a flush. An event that leaves the value as it was wakes nobody.
+
+## What each value means
+
+- **`isOnline`** is `navigator.onLine`: `true` means a network interface exists, not that the internet
+  answers. Without `navigator.onLine` it is `true`.
+- **`isFocused`** is `document.hasFocus()`, read on every `focus` and `blur`, not taken from the event:
+  focus moving into an iframe fires `blur` on the window while the page still has focus. Without
+  `document.hasFocus` it is `true`.
+- **`isVisible`** is `document.visibilityState !== 'hidden'`; without `document` it is `true`.
+- **The location**: `history.pushState` fires no event, so only the Navigation API sees a router push.
+  Without it the slot follows `popstate` and `hashchange`, and a push made by a router is seen at the next
+  of those events.
+
+Each check reads the API it needs, so the package loads under SSR and in workers and leaves the slot at
+the value above.

package/dist/index.cjs

@@ -0,0 +1,184 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  OIMBrowserFocusSlotSubscriptionListener: () => OIMBrowserFocusSlotSubscriptionListener,
+  OIMBrowserLocationSlotSubscriptionListener: () => OIMBrowserLocationSlotSubscriptionListener,
+  OIMBrowserOnlineSlotSubscriptionListener: () => OIMBrowserOnlineSlotSubscriptionListener,
+  OIMBrowserSlotSubscriptionListener: () => OIMBrowserSlotSubscriptionListener,
+  OIMBrowserVisibilitySlotSubscriptionListener: () => OIMBrowserVisibilitySlotSubscriptionListener,
+  createOIMBrowserFocusSingleSlotService: () => createOIMBrowserFocusSingleSlotService,
+  createOIMBrowserLocationSingleSlotService: () => createOIMBrowserLocationSingleSlotService,
+  createOIMBrowserOnlineSingleSlotService: () => createOIMBrowserOnlineSingleSlotService,
+  createOIMBrowserVisibilitySingleSlotService: () => createOIMBrowserVisibilitySingleSlotService
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/OIMBrowserSlotSubscriptionListener.ts
+var import_core = require("@oimdb/core");
+var OIMBrowserSlotSubscriptionListener = class {
+  constructor(slotContentEntityService) {
+    this.browserListenerDisposersBySlot = /* @__PURE__ */ new Map();
+    this.slotContentEntityService = slotContentEntityService;
+  }
+  onSlotFirstSubscribed(slot) {
+    const entitySlot = slot;
+    this.browserListenerDisposersBySlot.set(slot, this.listenToBrowser(() => {
+      this.writeCurrentEntity(entitySlot);
+    }));
+    this.writeCurrentEntity(entitySlot);
+  }
+  onSlotLastUnsubscribed(slot) {
+    const browserListenerDisposer = this.browserListenerDisposersBySlot.get(slot);
+    if (browserListenerDisposer === void 0) return;
+    this.browserListenerDisposersBySlot.delete(slot);
+    browserListenerDisposer();
+  }
+  writeCurrentEntity(entitySlot) {
+    const channelSlot = entitySlot.storeSlot.channelSlot;
+    if (!import_core.OIMChannelService.INSTANCE.isRefusingWrites(channelSlot)) {
+      this.slotContentEntityService.writeSlotContent(entitySlot, this.readCurrentEntity());
+      return;
+    }
+    const afterFlushDisposer = import_core.OIMChannelService.INSTANCE.subscribeAfterEachFlush(channelSlot, () => {
+      afterFlushDisposer();
+      if ((0, import_core.oimIsSlotReleased)(entitySlot)) return;
+      this.slotContentEntityService.writeSlotContent(entitySlot, this.readCurrentEntity());
+    });
+  }
+};
+
+// src/constants/OIM_NO_BROWSER_LISTENER_DISPOSER.ts
+var OIM_NO_BROWSER_LISTENER_DISPOSER = () => void 0;
+
+// src/utils/oimListenToBrowserWindow.ts
+function oimListenToBrowserWindow(eventNames, onBrowserChanged) {
+  const browserWindow = globalThis;
+  if (typeof browserWindow.addEventListener !== "function" || typeof browserWindow.removeEventListener !== "function") {
+    return OIM_NO_BROWSER_LISTENER_DISPOSER;
+  }
+  const addEventListener = browserWindow.addEventListener.bind(globalThis);
+  const removeEventListener = browserWindow.removeEventListener.bind(globalThis);
+  for (const eventName of eventNames) addEventListener(eventName, onBrowserChanged);
+  return () => {
+    for (const eventName of eventNames) removeEventListener(eventName, onBrowserChanged);
+  };
+}
+
+// src/OIMBrowserOnlineSlotSubscriptionListener.ts
+var OIMBrowserOnlineSlotSubscriptionListener = class extends OIMBrowserSlotSubscriptionListener {
+  readCurrentEntity() {
+    const navigatorOfBrowser = globalThis.navigator;
+    return { isOnline: typeof navigatorOfBrowser?.onLine === "boolean" ? navigatorOfBrowser.onLine : true };
+  }
+  listenToBrowser(onBrowserChanged) {
+    return oimListenToBrowserWindow(["online", "offline"], onBrowserChanged);
+  }
+};
+
+// src/createOIMBrowserSingleSlotService.ts
+var import_core2 = require("@oimdb/core");
+function createOIMBrowserSingleSlotService(createSlotSubscriptionListener, options) {
+  const slotContentService = (0, import_core2.createOIMSlotContentEntityService)({ defaults: options.defaults });
+  return (0, import_core2.createOIMSingleSlotService)({
+    defaults: options.defaults,
+    slotContentService,
+    slotSubscriptionListener: createSlotSubscriptionListener(slotContentService)
+  });
+}
+
+// src/createOIMBrowserOnlineSingleSlotService.ts
+function createOIMBrowserOnlineSingleSlotService(options = {}) {
+  return createOIMBrowserSingleSlotService((slotContentEntityService) => new OIMBrowserOnlineSlotSubscriptionListener(slotContentEntityService), options);
+}
+
+// src/OIMBrowserFocusSlotSubscriptionListener.ts
+var OIMBrowserFocusSlotSubscriptionListener = class extends OIMBrowserSlotSubscriptionListener {
+  readCurrentEntity() {
+    const documentOfBrowser = globalThis.document;
+    return { isFocused: typeof documentOfBrowser?.hasFocus === "function" ? documentOfBrowser.hasFocus.call(documentOfBrowser) : true };
+  }
+  listenToBrowser(onBrowserChanged) {
+    return oimListenToBrowserWindow(["focus", "blur"], onBrowserChanged);
+  }
+};
+
+// src/createOIMBrowserFocusSingleSlotService.ts
+function createOIMBrowserFocusSingleSlotService(options = {}) {
+  return createOIMBrowserSingleSlotService((slotContentEntityService) => new OIMBrowserFocusSlotSubscriptionListener(slotContentEntityService), options);
+}
+
+// src/OIMBrowserVisibilitySlotSubscriptionListener.ts
+var OIMBrowserVisibilitySlotSubscriptionListener = class extends OIMBrowserSlotSubscriptionListener {
+  readCurrentEntity() {
+    const documentOfBrowser = globalThis.document;
+    return { isVisible: documentOfBrowser?.visibilityState !== "hidden" };
+  }
+  listenToBrowser(onBrowserChanged) {
+    const documentOfBrowser = globalThis.document;
+    if (documentOfBrowser === void 0 || typeof documentOfBrowser.addEventListener !== "function") return OIM_NO_BROWSER_LISTENER_DISPOSER;
+    documentOfBrowser.addEventListener("visibilitychange", onBrowserChanged);
+    return () => {
+      documentOfBrowser.removeEventListener("visibilitychange", onBrowserChanged);
+    };
+  }
+};
+
+// src/createOIMBrowserVisibilitySingleSlotService.ts
+function createOIMBrowserVisibilitySingleSlotService(options = {}) {
+  return createOIMBrowserSingleSlotService((slotContentEntityService) => new OIMBrowserVisibilitySlotSubscriptionListener(slotContentEntityService), options);
+}
+
+// src/OIMBrowserLocationSlotSubscriptionListener.ts
+var OIMBrowserLocationSlotSubscriptionListener = class extends OIMBrowserSlotSubscriptionListener {
+  readCurrentEntity() {
+    const locationOfBrowser = globalThis.location;
+    if (locationOfBrowser === void 0) return { href: "", pathname: "", search: "", hash: "" };
+    return { href: locationOfBrowser.href, pathname: locationOfBrowser.pathname, search: locationOfBrowser.search, hash: locationOfBrowser.hash };
+  }
+  listenToBrowser(onBrowserChanged) {
+    const navigationOfBrowser = globalThis.navigation;
+    if (navigationOfBrowser !== void 0 && typeof navigationOfBrowser.addEventListener === "function") {
+      navigationOfBrowser.addEventListener("currententrychange", onBrowserChanged);
+      return () => {
+        navigationOfBrowser.removeEventListener("currententrychange", onBrowserChanged);
+      };
+    }
+    return oimListenToBrowserWindow(["popstate", "hashchange"], onBrowserChanged);
+  }
+};
+
+// src/createOIMBrowserLocationSingleSlotService.ts
+function createOIMBrowserLocationSingleSlotService(options = {}) {
+  return createOIMBrowserSingleSlotService((slotContentEntityService) => new OIMBrowserLocationSlotSubscriptionListener(slotContentEntityService), options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OIMBrowserFocusSlotSubscriptionListener,
+  OIMBrowserLocationSlotSubscriptionListener,
+  OIMBrowserOnlineSlotSubscriptionListener,
+  OIMBrowserSlotSubscriptionListener,
+  OIMBrowserVisibilitySlotSubscriptionListener,
+  createOIMBrowserFocusSingleSlotService,
+  createOIMBrowserLocationSingleSlotService,
+  createOIMBrowserOnlineSingleSlotService,
+  createOIMBrowserVisibilitySingleSlotService
+});

package/dist/index.d.cts

@@ -0,0 +1,67 @@
+import { IOIMSlotSubscriptionListener, OIMSlotContentEntityService, TOIMSlot, TOIMDisposer, OIMSingleSlotService, TOIMEntityContentSlot, OIMDefaults } from '@oimdb/core';
+
+declare abstract class OIMBrowserSlotSubscriptionListener<TEntity extends object> implements IOIMSlotSubscriptionListener {
+    private readonly slotContentEntityService;
+    private readonly browserListenerDisposersBySlot;
+    constructor(slotContentEntityService: OIMSlotContentEntityService<TEntity>);
+    onSlotFirstSubscribed(slot: TOIMSlot): void;
+    onSlotLastUnsubscribed(slot: TOIMSlot): void;
+    protected abstract readCurrentEntity(): TEntity;
+    protected abstract listenToBrowser(onBrowserChanged: () => void): TOIMDisposer;
+    private writeCurrentEntity;
+}
+
+type TOIMBrowserSingleSlotService<TEntity extends object> = OIMSingleSlotService<TOIMEntityContentSlot<TEntity>, OIMSlotContentEntityService<TEntity>>;
+
+type TOIMBrowserSingleSlotServiceOptions = {
+    defaults?: OIMDefaults | undefined;
+};
+
+type TOIMBrowserOnlineEntity = {
+    readonly isOnline: boolean;
+};
+
+declare function createOIMBrowserOnlineSingleSlotService(options?: TOIMBrowserSingleSlotServiceOptions): TOIMBrowserSingleSlotService<TOIMBrowserOnlineEntity>;
+
+declare class OIMBrowserOnlineSlotSubscriptionListener extends OIMBrowserSlotSubscriptionListener<TOIMBrowserOnlineEntity> {
+    protected readCurrentEntity(): TOIMBrowserOnlineEntity;
+    protected listenToBrowser(onBrowserChanged: () => void): TOIMDisposer;
+}
+
+type TOIMBrowserFocusEntity = {
+    readonly isFocused: boolean;
+};
+
+declare function createOIMBrowserFocusSingleSlotService(options?: TOIMBrowserSingleSlotServiceOptions): TOIMBrowserSingleSlotService<TOIMBrowserFocusEntity>;
+
+declare class OIMBrowserFocusSlotSubscriptionListener extends OIMBrowserSlotSubscriptionListener<TOIMBrowserFocusEntity> {
+    protected readCurrentEntity(): TOIMBrowserFocusEntity;
+    protected listenToBrowser(onBrowserChanged: () => void): TOIMDisposer;
+}
+
+type TOIMBrowserVisibilityEntity = {
+    readonly isVisible: boolean;
+};
+
+declare function createOIMBrowserVisibilitySingleSlotService(options?: TOIMBrowserSingleSlotServiceOptions): TOIMBrowserSingleSlotService<TOIMBrowserVisibilityEntity>;
+
+declare class OIMBrowserVisibilitySlotSubscriptionListener extends OIMBrowserSlotSubscriptionListener<TOIMBrowserVisibilityEntity> {
+    protected readCurrentEntity(): TOIMBrowserVisibilityEntity;
+    protected listenToBrowser(onBrowserChanged: () => void): TOIMDisposer;
+}
+
+type TOIMBrowserLocationEntity = {
+    readonly href: string;
+    readonly pathname: string;
+    readonly search: string;
+    readonly hash: string;
+};
+
+declare function createOIMBrowserLocationSingleSlotService(options?: TOIMBrowserSingleSlotServiceOptions): TOIMBrowserSingleSlotService<TOIMBrowserLocationEntity>;
+
+declare class OIMBrowserLocationSlotSubscriptionListener extends OIMBrowserSlotSubscriptionListener<TOIMBrowserLocationEntity> {
+    protected readCurrentEntity(): TOIMBrowserLocationEntity;
+    protected listenToBrowser(onBrowserChanged: () => void): TOIMDisposer;
+}
+
+export { OIMBrowserFocusSlotSubscriptionListener, OIMBrowserLocationSlotSubscriptionListener, OIMBrowserOnlineSlotSubscriptionListener, OIMBrowserSlotSubscriptionListener, OIMBrowserVisibilitySlotSubscriptionListener, type TOIMBrowserFocusEntity, type TOIMBrowserLocationEntity, type TOIMBrowserOnlineEntity, type TOIMBrowserSingleSlotService, type TOIMBrowserSingleSlotServiceOptions, type TOIMBrowserVisibilityEntity, createOIMBrowserFocusSingleSlotService, createOIMBrowserLocationSingleSlotService, createOIMBrowserOnlineSingleSlotService, createOIMBrowserVisibilitySingleSlotService };

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+import { IOIMSlotSubscriptionListener, OIMSlotContentEntityService, TOIMSlot, TOIMDisposer, OIMSingleSlotService, TOIMEntityContentSlot, OIMDefaults } from '@oimdb/core';
+
+declare abstract class OIMBrowserSlotSubscriptionListener<TEntity extends object> implements IOIMSlotSubscriptionListener {
+    private readonly slotContentEntityService;
+    private readonly browserListenerDisposersBySlot;
+    constructor(slotContentEntityService: OIMSlotContentEntityService<TEntity>);
+    onSlotFirstSubscribed(slot: TOIMSlot): void;
+    onSlotLastUnsubscribed(slot: TOIMSlot): void;
+    protected abstract readCurrentEntity(): TEntity;
+    protected abstract listenToBrowser(onBrowserChanged: () => void): TOIMDisposer;
+    private writeCurrentEntity;
+}
+
+type TOIMBrowserSingleSlotService<TEntity extends object> = OIMSingleSlotService<TOIMEntityContentSlot<TEntity>, OIMSlotContentEntityService<TEntity>>;
+
+type TOIMBrowserSingleSlotServiceOptions = {
+    defaults?: OIMDefaults | undefined;
+};
+
+type TOIMBrowserOnlineEntity = {
+    readonly isOnline: boolean;
+};
+
+declare function createOIMBrowserOnlineSingleSlotService(options?: TOIMBrowserSingleSlotServiceOptions): TOIMBrowserSingleSlotService<TOIMBrowserOnlineEntity>;
+
+declare class OIMBrowserOnlineSlotSubscriptionListener extends OIMBrowserSlotSubscriptionListener<TOIMBrowserOnlineEntity> {
+    protected readCurrentEntity(): TOIMBrowserOnlineEntity;
+    protected listenToBrowser(onBrowserChanged: () => void): TOIMDisposer;
+}
+
+type TOIMBrowserFocusEntity = {
+    readonly isFocused: boolean;
+};
+
+declare function createOIMBrowserFocusSingleSlotService(options?: TOIMBrowserSingleSlotServiceOptions): TOIMBrowserSingleSlotService<TOIMBrowserFocusEntity>;
+
+declare class OIMBrowserFocusSlotSubscriptionListener extends OIMBrowserSlotSubscriptionListener<TOIMBrowserFocusEntity> {
+    protected readCurrentEntity(): TOIMBrowserFocusEntity;
+    protected listenToBrowser(onBrowserChanged: () => void): TOIMDisposer;
+}
+
+type TOIMBrowserVisibilityEntity = {
+    readonly isVisible: boolean;
+};
+
+declare function createOIMBrowserVisibilitySingleSlotService(options?: TOIMBrowserSingleSlotServiceOptions): TOIMBrowserSingleSlotService<TOIMBrowserVisibilityEntity>;
+
+declare class OIMBrowserVisibilitySlotSubscriptionListener extends OIMBrowserSlotSubscriptionListener<TOIMBrowserVisibilityEntity> {
+    protected readCurrentEntity(): TOIMBrowserVisibilityEntity;
+    protected listenToBrowser(onBrowserChanged: () => void): TOIMDisposer;
+}
+
+type TOIMBrowserLocationEntity = {
+    readonly href: string;
+    readonly pathname: string;
+    readonly search: string;
+    readonly hash: string;
+};
+
+declare function createOIMBrowserLocationSingleSlotService(options?: TOIMBrowserSingleSlotServiceOptions): TOIMBrowserSingleSlotService<TOIMBrowserLocationEntity>;
+
+declare class OIMBrowserLocationSlotSubscriptionListener extends OIMBrowserSlotSubscriptionListener<TOIMBrowserLocationEntity> {
+    protected readCurrentEntity(): TOIMBrowserLocationEntity;
+    protected listenToBrowser(onBrowserChanged: () => void): TOIMDisposer;
+}
+
+export { OIMBrowserFocusSlotSubscriptionListener, OIMBrowserLocationSlotSubscriptionListener, OIMBrowserOnlineSlotSubscriptionListener, OIMBrowserSlotSubscriptionListener, OIMBrowserVisibilitySlotSubscriptionListener, type TOIMBrowserFocusEntity, type TOIMBrowserLocationEntity, type TOIMBrowserOnlineEntity, type TOIMBrowserSingleSlotService, type TOIMBrowserSingleSlotServiceOptions, type TOIMBrowserVisibilityEntity, createOIMBrowserFocusSingleSlotService, createOIMBrowserLocationSingleSlotService, createOIMBrowserOnlineSingleSlotService, createOIMBrowserVisibilitySingleSlotService };

package/dist/index.js

@@ -0,0 +1,149 @@
+// src/OIMBrowserSlotSubscriptionListener.ts
+import { OIMChannelService, oimIsSlotReleased } from "@oimdb/core";
+var OIMBrowserSlotSubscriptionListener = class {
+  constructor(slotContentEntityService) {
+    this.browserListenerDisposersBySlot = /* @__PURE__ */ new Map();
+    this.slotContentEntityService = slotContentEntityService;
+  }
+  onSlotFirstSubscribed(slot) {
+    const entitySlot = slot;
+    this.browserListenerDisposersBySlot.set(slot, this.listenToBrowser(() => {
+      this.writeCurrentEntity(entitySlot);
+    }));
+    this.writeCurrentEntity(entitySlot);
+  }
+  onSlotLastUnsubscribed(slot) {
+    const browserListenerDisposer = this.browserListenerDisposersBySlot.get(slot);
+    if (browserListenerDisposer === void 0) return;
+    this.browserListenerDisposersBySlot.delete(slot);
+    browserListenerDisposer();
+  }
+  writeCurrentEntity(entitySlot) {
+    const channelSlot = entitySlot.storeSlot.channelSlot;
+    if (!OIMChannelService.INSTANCE.isRefusingWrites(channelSlot)) {
+      this.slotContentEntityService.writeSlotContent(entitySlot, this.readCurrentEntity());
+      return;
+    }
+    const afterFlushDisposer = OIMChannelService.INSTANCE.subscribeAfterEachFlush(channelSlot, () => {
+      afterFlushDisposer();
+      if (oimIsSlotReleased(entitySlot)) return;
+      this.slotContentEntityService.writeSlotContent(entitySlot, this.readCurrentEntity());
+    });
+  }
+};
+
+// src/constants/OIM_NO_BROWSER_LISTENER_DISPOSER.ts
+var OIM_NO_BROWSER_LISTENER_DISPOSER = () => void 0;
+
+// src/utils/oimListenToBrowserWindow.ts
+function oimListenToBrowserWindow(eventNames, onBrowserChanged) {
+  const browserWindow = globalThis;
+  if (typeof browserWindow.addEventListener !== "function" || typeof browserWindow.removeEventListener !== "function") {
+    return OIM_NO_BROWSER_LISTENER_DISPOSER;
+  }
+  const addEventListener = browserWindow.addEventListener.bind(globalThis);
+  const removeEventListener = browserWindow.removeEventListener.bind(globalThis);
+  for (const eventName of eventNames) addEventListener(eventName, onBrowserChanged);
+  return () => {
+    for (const eventName of eventNames) removeEventListener(eventName, onBrowserChanged);
+  };
+}
+
+// src/OIMBrowserOnlineSlotSubscriptionListener.ts
+var OIMBrowserOnlineSlotSubscriptionListener = class extends OIMBrowserSlotSubscriptionListener {
+  readCurrentEntity() {
+    const navigatorOfBrowser = globalThis.navigator;
+    return { isOnline: typeof navigatorOfBrowser?.onLine === "boolean" ? navigatorOfBrowser.onLine : true };
+  }
+  listenToBrowser(onBrowserChanged) {
+    return oimListenToBrowserWindow(["online", "offline"], onBrowserChanged);
+  }
+};
+
+// src/createOIMBrowserSingleSlotService.ts
+import { createOIMSingleSlotService, createOIMSlotContentEntityService } from "@oimdb/core";
+function createOIMBrowserSingleSlotService(createSlotSubscriptionListener, options) {
+  const slotContentService = createOIMSlotContentEntityService({ defaults: options.defaults });
+  return createOIMSingleSlotService({
+    defaults: options.defaults,
+    slotContentService,
+    slotSubscriptionListener: createSlotSubscriptionListener(slotContentService)
+  });
+}
+
+// src/createOIMBrowserOnlineSingleSlotService.ts
+function createOIMBrowserOnlineSingleSlotService(options = {}) {
+  return createOIMBrowserSingleSlotService((slotContentEntityService) => new OIMBrowserOnlineSlotSubscriptionListener(slotContentEntityService), options);
+}
+
+// src/OIMBrowserFocusSlotSubscriptionListener.ts
+var OIMBrowserFocusSlotSubscriptionListener = class extends OIMBrowserSlotSubscriptionListener {
+  readCurrentEntity() {
+    const documentOfBrowser = globalThis.document;
+    return { isFocused: typeof documentOfBrowser?.hasFocus === "function" ? documentOfBrowser.hasFocus.call(documentOfBrowser) : true };
+  }
+  listenToBrowser(onBrowserChanged) {
+    return oimListenToBrowserWindow(["focus", "blur"], onBrowserChanged);
+  }
+};
+
+// src/createOIMBrowserFocusSingleSlotService.ts
+function createOIMBrowserFocusSingleSlotService(options = {}) {
+  return createOIMBrowserSingleSlotService((slotContentEntityService) => new OIMBrowserFocusSlotSubscriptionListener(slotContentEntityService), options);
+}
+
+// src/OIMBrowserVisibilitySlotSubscriptionListener.ts
+var OIMBrowserVisibilitySlotSubscriptionListener = class extends OIMBrowserSlotSubscriptionListener {
+  readCurrentEntity() {
+    const documentOfBrowser = globalThis.document;
+    return { isVisible: documentOfBrowser?.visibilityState !== "hidden" };
+  }
+  listenToBrowser(onBrowserChanged) {
+    const documentOfBrowser = globalThis.document;
+    if (documentOfBrowser === void 0 || typeof documentOfBrowser.addEventListener !== "function") return OIM_NO_BROWSER_LISTENER_DISPOSER;
+    documentOfBrowser.addEventListener("visibilitychange", onBrowserChanged);
+    return () => {
+      documentOfBrowser.removeEventListener("visibilitychange", onBrowserChanged);
+    };
+  }
+};
+
+// src/createOIMBrowserVisibilitySingleSlotService.ts
+function createOIMBrowserVisibilitySingleSlotService(options = {}) {
+  return createOIMBrowserSingleSlotService((slotContentEntityService) => new OIMBrowserVisibilitySlotSubscriptionListener(slotContentEntityService), options);
+}
+
+// src/OIMBrowserLocationSlotSubscriptionListener.ts
+var OIMBrowserLocationSlotSubscriptionListener = class extends OIMBrowserSlotSubscriptionListener {
+  readCurrentEntity() {
+    const locationOfBrowser = globalThis.location;
+    if (locationOfBrowser === void 0) return { href: "", pathname: "", search: "", hash: "" };
+    return { href: locationOfBrowser.href, pathname: locationOfBrowser.pathname, search: locationOfBrowser.search, hash: locationOfBrowser.hash };
+  }
+  listenToBrowser(onBrowserChanged) {
+    const navigationOfBrowser = globalThis.navigation;
+    if (navigationOfBrowser !== void 0 && typeof navigationOfBrowser.addEventListener === "function") {
+      navigationOfBrowser.addEventListener("currententrychange", onBrowserChanged);
+      return () => {
+        navigationOfBrowser.removeEventListener("currententrychange", onBrowserChanged);
+      };
+    }
+    return oimListenToBrowserWindow(["popstate", "hashchange"], onBrowserChanged);
+  }
+};
+
+// src/createOIMBrowserLocationSingleSlotService.ts
+function createOIMBrowserLocationSingleSlotService(options = {}) {
+  return createOIMBrowserSingleSlotService((slotContentEntityService) => new OIMBrowserLocationSlotSubscriptionListener(slotContentEntityService), options);
+}
+export {
+  OIMBrowserFocusSlotSubscriptionListener,
+  OIMBrowserLocationSlotSubscriptionListener,
+  OIMBrowserOnlineSlotSubscriptionListener,
+  OIMBrowserSlotSubscriptionListener,
+  OIMBrowserVisibilitySlotSubscriptionListener,
+  createOIMBrowserFocusSingleSlotService,
+  createOIMBrowserLocationSingleSlotService,
+  createOIMBrowserOnlineSingleSlotService,
+  createOIMBrowserVisibilitySingleSlotService
+};