chayns-api 3.0.1 → 3.1.0-beta.1

package/dist/cjs/wrapper/StaticChaynsApi.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _moduleWrapper = require("../components/moduleWrapper");
 var _IChaynsReact = require("../types/IChaynsReact");
-var _deviceHelper = _interopRequireDefault(require("../util/deviceHelper"));
+var _deviceHelper = _interopRequireDefault(require("../utils/deviceHelper"));
 var _AppWrapper = require("./AppWrapper");
 var _FrameWrapper = require("./FrameWrapper");
 var _ModuleFederationWrapper = require("./ModuleFederationWrapper");

package/dist/esm/calls/index.js

@@ -1,4 +1,5 @@
 import { moduleWrapper } from '../components/moduleWrapper';
+import { getCurrentChaynsHistoryLayer } from '../contexts/HistoryLayerContext';
 export const addGeoLocationListener = (...args) => moduleWrapper.current.functions.addGeoLocationListener(...args);
 export const addScrollListener = (...args) => moduleWrapper.current.functions.addScrollListener(...args);
 export const addVisibilityChangeListener = (...args) => moduleWrapper.current.functions.addVisibilityChangeListener(...args);
@@ -54,6 +55,7 @@ export const createDialog = config => moduleWrapper.current.functions.createDial
 export const setOverlay = (...args) => moduleWrapper.current.functions.setOverlay(...args);
 export const addAnonymousAccount = () => moduleWrapper.current.functions.addAnonymousAccount();
 export const getUser = () => moduleWrapper.current.values.user;
+export const getChaynsHistoryLayer = () => getCurrentChaynsHistoryLayer();
 export const getSite = () => moduleWrapper.current.values.site;
 export const getCurrentPage = () => moduleWrapper.current.values.currentPage;
 export const getDevice = () => moduleWrapper.current.values.device;

package/dist/esm/calls/visibilityChangeListener.js

@@ -1,4 +1,4 @@
-import { addApiListener, dispatchApiEvent, removeApiListener } from '../helper/apiListenerHelper';
+import { addApiListener, dispatchApiEvent, removeApiListener } from '../utils/apiListener';
 const key = 'visibilityChangeListener';
 const handleVisibilityChange = () => {
   dispatchApiEvent(key, {

package/dist/esm/components/ChaynsProvider.js

@@ -3,13 +3,15 @@ import htmlEscape from 'htmlescape';
 import React, { useEffect, useRef, useState } from 'react';
 import { useIsomorphicLayoutEffect } from '../hooks/useIsomorphicLayoutEffect';
 import { AppName } from '../types/IChaynsReact';
-import getDeviceInfo from '../util/deviceHelper';
+import getDeviceInfo from '../utils/deviceHelper';
 import { AppWrapper } from '../wrapper/AppWrapper';
 import { FrameWrapper } from '../wrapper/FrameWrapper';
 import { ModuleFederationWrapper } from '../wrapper/ModuleFederationWrapper';
 import { SsrWrapper } from '../wrapper/SsrWrapper';
 import { ChaynsContext } from './ChaynsContext';
 import { addModuleWrapper, moduleWrapper, removeModuleWrapper } from './moduleWrapper';
+import { ChaynsHistoryLayerProvider, useChaynsHistoryLayerContext } from '../contexts/HistoryLayerContext';
+import { getOrInitRootChaynsHistoryLayer } from '../utils/history/rootLayer';
 const isServer = typeof window === 'undefined';
 const InitialDataProvider = React.memo(t0 => {
   const $ = _c(6);
@@ -59,11 +61,18 @@ const ChaynsProvider = ({
   customFunctions,
   renderedByServer,
   isModule,
-  chaynsApiId
+  chaynsApiId,
+  historyLayer,
+  history,
+  isHistoryDisabled,
+  segmentCount
 }) => {
-  var _ref, _crypto, _customWrapper$curren, _customWrapper$curren2;
+  var _ref, _crypto, _customWrapper$curren, _customWrapper$curren3, _customWrapper$curren4;
   const customWrapper = useRef(null);
   const idRef = useRef((_ref = chaynsApiId !== null && chaynsApiId !== void 0 ? chaynsApiId : (_crypto = crypto) === null || _crypto === void 0 ? void 0 : _crypto.randomUUID()) !== null && _ref !== void 0 ? _ref : Math.random().toString());
+  const contextLayer = useChaynsHistoryLayerContext();
+  const parentLayerRef = useRef(contextLayer);
+  const rootLayerRef = useRef(null);
   if (!customWrapper.current) {
     if (isModule) {
       if (data && functions) {
@@ -91,9 +100,10 @@ const ChaynsProvider = ({
       customWrapper.current.chaynsApiId = idRef.current;
     }
   }
+  const [effectiveLayer, setEffectiveLayer] = useState(historyLayer !== null && historyLayer !== void 0 ? historyLayer : null);
   const [isInitialized, setIsInitialized] = useState(!!((_customWrapper$curren = customWrapper.current) !== null && _customWrapper$curren !== void 0 && _customWrapper$curren.values));
   useEffect(() => {
-    void (async () => {
+    void (async (_customWrapper$curren2, _ref2) => {
       await customWrapper.current.init();
       customWrapper.current.addDataListener(({
         type,
@@ -101,6 +111,15 @@ const ChaynsProvider = ({
       }) => {
         customWrapper.current.emitChange();
       });
+      parentLayerRef.current = (_customWrapper$curren2 = customWrapper.current.functions.getHistoryLayer()) !== null && _customWrapper$curren2 !== void 0 ? _customWrapper$curren2 : contextLayer;
+      if (!rootLayerRef.current && !historyLayer && !parentLayerRef.current) {
+        rootLayerRef.current = getOrInitRootChaynsHistoryLayer(history === null || history === void 0 ? void 0 : history.url, history === null || history === void 0 ? void 0 : history.segmentCount).rootLayer;
+      }
+      const layer = (_ref2 = historyLayer !== null && historyLayer !== void 0 ? historyLayer : parentLayerRef.current) !== null && _ref2 !== void 0 ? _ref2 : rootLayerRef.current;
+      if (typeof segmentCount === 'number' && layer.getSegmentCount() !== segmentCount) {
+        layer.setSegmentCount(segmentCount);
+      }
+      setEffectiveLayer(layer);
       if (!isInitialized) {
         setIsInitialized(true);
       }
@@ -125,10 +144,19 @@ const ChaynsProvider = ({
       removeModuleWrapper(id, customWrapper.current);
     };
   }, []);
+  let isDisabled = Boolean((_customWrapper$curren3 = customWrapper.current.values) === null || _customWrapper$curren3 === void 0 ? void 0 : _customWrapper$curren3.isHistoryDisabled);
+  if (typeof isHistoryDisabled === 'boolean' && !isDisabled) {
+    isDisabled = isHistoryDisabled;
+  }
+  if ((historyLayer === null || historyLayer === void 0 ? void 0 : historyLayer.id) === 'root') {
+    isDisabled = false;
+  }
   return React.createElement(React.Fragment, null, isInitialized && React.createElement(ChaynsContext.Provider, {
     value: customWrapper.current
-  }, children), React.createElement(InitialDataProvider, {
-    data: (_customWrapper$curren2 = customWrapper.current) === null || _customWrapper$curren2 === void 0 ? void 0 : _customWrapper$curren2.values,
+  }, effectiveLayer && !isDisabled ? React.createElement(ChaynsHistoryLayerProvider, {
+    layer: effectiveLayer
+  }, children) : children), React.createElement(InitialDataProvider, {
+    data: (_customWrapper$curren4 = customWrapper.current) === null || _customWrapper$curren4 === void 0 ? void 0 : _customWrapper$curren4.values,
     renderedByServer: renderedByServer
   }));
 };

package/dist/esm/components/withHydrationBoundary.js

@@ -1,6 +1,6 @@
 function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
 import React, { useContext, useEffect, useState } from 'react';
-import { HydrationContext } from '../constants';
+import { HydrationContext } from '../contexts';
 function withHydrationBoundary(Component, initializer, useHydrationId, useProps) {
   const stores = {};
   return ({

package/dist/esm/constants/index.js

@@ -1,3 +1 @@
-export * from './hydrationContext';
-export * from './DefaultLoginDialogOptions';
-export * from './moduleContext';
+export * from './DefaultLoginDialogOptions';

package/dist/esm/contexts/HistoryLayerContext.js

@@ -0,0 +1,76 @@
+import { c as _c } from "react-compiler-runtime";
+import React, { createContext, useContext } from 'react';
+import { useIsomorphicLayoutEffect } from '../hooks/useIsomorphicLayoutEffect';
+const _layerStack = [];
+export function pushChaynsHistoryLayer(layer) {
+  _layerStack.push(layer);
+}
+export function popChaynsHistoryLayer(layer) {
+  const index = _layerStack.lastIndexOf(layer);
+  if (index > -1) {
+    _layerStack.splice(index, 1);
+  }
+}
+export function getCurrentChaynsHistoryLayer() {
+  return _layerStack.length > 0 ? _layerStack[_layerStack.length - 1] : null;
+}
+const ChaynsHistoryLayerContext = createContext(null);
+ChaynsHistoryLayerContext.displayName = 'ChaynsHistoryLayerContext';
+export const ChaynsHistoryLayerProvider = t0 => {
+  const $ = _c(6);
+  const {
+    layer,
+    children
+  } = t0;
+  let t1;
+  let t2;
+  if ($[0] !== layer) {
+    t1 = () => {
+      pushChaynsHistoryLayer(layer);
+      return () => popChaynsHistoryLayer(layer);
+    };
+    t2 = [layer];
+    $[0] = layer;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  useIsomorphicLayoutEffect(t1, t2);
+  let t3;
+  if ($[3] !== children || $[4] !== layer) {
+    t3 = React.createElement(ChaynsHistoryLayerContext.Provider, {
+      value: layer
+    }, children);
+    $[3] = children;
+    $[4] = layer;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  return t3;
+};
+export const ChaynsHistoryLayerOverrideProvider = t0 => {
+  const $ = _c(3);
+  const {
+    layer,
+    children
+  } = t0;
+  let t1;
+  if ($[0] !== children || $[1] !== layer) {
+    t1 = React.createElement(ChaynsHistoryLayerContext.Provider, {
+      value: layer
+    }, children);
+    $[0] = children;
+    $[1] = layer;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+};
+export function useChaynsHistoryLayerContext() {
+  return useContext(ChaynsHistoryLayerContext);
+}
+export default ChaynsHistoryLayerContext;

package/dist/esm/contexts/index.js

@@ -0,0 +1,3 @@
+export * from './hydrationContext';
+export * from './moduleContext';
+export * from './HistoryLayerContext';

package/dist/esm/handler/history/FrameHistoryLayer.js

@@ -0,0 +1,105 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { EventBus } from '../../utils/EventBus';
+import { shallowEqualArr } from '../../utils/equality';
+import { normalizeHistoryRouteInput, normalizeHistorySegments } from '../../utils/history/segments';
+export class FrameHistoryLayer {
+  constructor(bridge, initial) {
+    _defineProperty(this, "id", void 0);
+    _defineProperty(this, "depth", void 0);
+    _defineProperty(this, "_segments", void 0);
+    _defineProperty(this, "_params", void 0);
+    _defineProperty(this, "_hash", void 0);
+    _defineProperty(this, "_state", void 0);
+    _defineProperty(this, "_activeChildId", void 0);
+    _defineProperty(this, "_segmentCount", void 0);
+    _defineProperty(this, "bus", new EventBus());
+    _defineProperty(this, "bridge", void 0);
+    this.id = initial.id;
+    this.depth = initial.depth;
+    this._segments = normalizeHistorySegments(initial.segments);
+    this._params = initial.params;
+    this._hash = initial.hash;
+    this._state = initial.state;
+    this._activeChildId = initial.activeChildId;
+    this._segmentCount = initial.segmentCount;
+    this.bridge = bridge;
+  }
+  getSegmentCount() {
+    return this._segmentCount;
+  }
+  setSegmentCount(n) {
+    if (n === this._segmentCount) {
+      return;
+    }
+    this._segmentCount = n;
+    void this.bridge.setSegmentCount(n);
+  }
+  createChildLayer(_id) {
+    throw new Error('[chaynsHistory] FrameHistoryLayer does not support createChildLayer. ' + 'Manage sub-routing within the iframe with a local initRootChaynsHistoryLayer.');
+  }
+  destroyChildLayer(_id) {}
+  setActiveChild(id, init) {
+    return this.bridge.setActiveChild(id, init);
+  }
+  getActiveChildId() {
+    return this._activeChildId;
+  }
+  getChildLayer(_id) {
+    return undefined;
+  }
+  getRoute() {
+    return [...this._segments];
+  }
+  setRoute(route, opts) {
+    const normalizedRoute = normalizeHistoryRouteInput(route);
+    if (shallowEqualArr(this._segments, normalizedRoute)) {
+      return;
+    }
+    void this.bridge.setRoute(normalizedRoute, opts);
+  }
+  getParams() {
+    return {
+      ...this._params
+    };
+  }
+  setParams(params, opts) {
+    void this.bridge.setParams(params, opts);
+  }
+  getHash() {
+    return this._hash;
+  }
+  setHash(hash, opts) {
+    void this.bridge.setHash(hash, opts);
+  }
+  getState() {
+    return this._state;
+  }
+  setState(state, opts) {
+    void this.bridge.setState(state, opts);
+  }
+  navigate(opts) {
+    return this.bridge.navigate(opts);
+  }
+  addBlock(callback, opts) {
+    let removeFn = null;
+    void this.bridge.addBlock(callback, opts).then(fn => {
+      removeFn = fn;
+    });
+    return () => {
+      var _removeFn;
+      return (_removeFn = removeFn) === null || _removeFn === void 0 ? void 0 : _removeFn();
+    };
+  }
+  addEventListener(type, handler) {
+    return this.bus.on(type, handler);
+  }
+  _applyAndEmit(e) {
+    this._segments = normalizeHistorySegments(e.segments);
+    this._params = e.params;
+    this._hash = e.hash;
+    this._state = e.state;
+    this.bus.emit(e.type, e);
+  }
+}

package/dist/esm/handler/history/HistoryLayer.js

@@ -0,0 +1,321 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { EventBus } from '../../utils/EventBus';
+import { resolveSegmentsFrom } from '../../utils/history/rootLayer';
+import { normalizeHistoryRouteInput, normalizeHistorySegments } from '../../utils/history/segments';
+const RESERVED_STATE_KEYS = ['activeChild', 'childState', '__params', '__hash'];
+export class ChaynsHistoryLayer {
+  constructor(init) {
+    var _init$segmentCount, _init$segments;
+    _defineProperty(this, "id", void 0);
+    _defineProperty(this, "depth", void 0);
+    _defineProperty(this, "parent", void 0);
+    _defineProperty(this, "children", new Map());
+    _defineProperty(this, "activeChildId", null);
+    _defineProperty(this, "segmentCount", 0);
+    _defineProperty(this, "segments", []);
+    _defineProperty(this, "ownState", {});
+    _defineProperty(this, "_params", {});
+    _defineProperty(this, "_hash", undefined);
+    _defineProperty(this, "bus", new EventBus());
+    _defineProperty(this, "deps", void 0);
+    _defineProperty(this, "_bootstrapPool", null);
+    _defineProperty(this, "_bootstrapUrlResolver", null);
+    _defineProperty(this, "isDestroyed", false);
+    this.id = init.id;
+    this.parent = init.parent;
+    this.depth = init.parent ? init.parent.depth + 1 : 0;
+    this.deps = init.deps;
+    this.segmentCount = (_init$segmentCount = init.segmentCount) !== null && _init$segmentCount !== void 0 ? _init$segmentCount : 0;
+    this.segments = normalizeHistorySegments((_init$segments = init.segments) !== null && _init$segments !== void 0 ? _init$segments : []);
+  }
+  getSegmentCount() {
+    return this.segmentCount;
+  }
+  setSegmentCount(n) {
+    if (n < 0 || !Number.isInteger(n)) {
+      return;
+    }
+    const prev = this.segmentCount;
+    if (n === prev) {
+      return;
+    }
+    this.segmentCount = n;
+    if (this._isInActiveChain()) {
+      if (n < prev) {
+        const excess = this.segments.splice(n);
+        if (excess.length > 0 && this.activeChildId) {
+          const child = this.children.get(this.activeChildId);
+          if (child) {
+            child._setOwnSegmentsSilent([...excess, ...child._getOwnSegments()]);
+          }
+        }
+      } else if (n > prev && this.segments.length === 0) {
+        const root = this.deps.getRoot();
+        const bootstrapSegs = root._consumeBootstrapSegments(n);
+        if (bootstrapSegs) {
+          this.segments = normalizeHistorySegments(bootstrapSegs);
+        }
+      }
+      void this.deps.getQueue().enqueue({
+        kind: 'setRoute',
+        layerId: this.id,
+        segments: [...this.segments],
+        opts: {},
+        _notifyEvenIfUnchanged: true,
+        _skipCommit: true
+      });
+    }
+  }
+  createChildLayer(id) {
+    if (this.children.has(id)) {
+      throw new Error(`[chaynsHistory] Child layer with id "${id}" already exists on layer "${this.id}".`);
+    }
+    const segments = resolveSegmentsFrom(undefined, this.getCumulativeSegmentCount());
+    const child = new ChaynsHistoryLayer({
+      id,
+      parent: this,
+      deps: this.deps,
+      segments,
+      segmentCount: segments.length
+    });
+    this.children.set(id, child);
+    return child;
+  }
+  destroyChildLayer(id) {
+    const child = this.children.get(id);
+    if (!child) return;
+    child.markDestroyed();
+    this.children.delete(id);
+    if (this.activeChildId === id) {
+      void this.deps.getQueue().enqueue({
+        kind: 'setActiveChild',
+        layerId: this.id,
+        childId: null
+      });
+    }
+  }
+  getChildLayer(id) {
+    return this.children.get(id);
+  }
+  getActiveChildId() {
+    return this.activeChildId;
+  }
+  setActiveChild(id, init) {
+    if (this.isDestroyed) return Promise.resolve({
+      isOk: false,
+      reason: 'destroyed'
+    });
+    return this.deps.getQueue().enqueue({
+      kind: 'setActiveChild',
+      layerId: this.id,
+      childId: id,
+      init: init ? {
+        ...init,
+        route: init.route !== undefined ? ChaynsHistoryLayer.normalizeRoute(init.route) : undefined
+      } : undefined
+    });
+  }
+  getRoute() {
+    return [...this.segments];
+  }
+  setRoute(route, opts) {
+    if (this.isDestroyed) return;
+    void this.deps.getQueue().enqueue({
+      kind: 'setRoute',
+      layerId: this.id,
+      segments: ChaynsHistoryLayer.normalizeRoute(route),
+      opts: opts !== null && opts !== void 0 ? opts : {}
+    });
+  }
+  getParams() {
+    return {
+      ...this._params
+    };
+  }
+  setParams(params, opts) {
+    if (this.isDestroyed) return;
+    void this.deps.getQueue().enqueue({
+      kind: 'setParams',
+      layerId: this.id,
+      params: {
+        ...params
+      },
+      opts: opts !== null && opts !== void 0 ? opts : {}
+    });
+  }
+  getHash() {
+    var _this$_hash;
+    return (_this$_hash = this._hash) !== null && _this$_hash !== void 0 ? _this$_hash : '';
+  }
+  setHash(hash, opts) {
+    if (this.isDestroyed) return;
+    const normalized = hash.startsWith('#') ? hash.slice(1) : hash;
+    void this.deps.getQueue().enqueue({
+      kind: 'setHash',
+      layerId: this.id,
+      hash: normalized,
+      opts: opts !== null && opts !== void 0 ? opts : {}
+    });
+  }
+  getState() {
+    return {
+      ...this.ownState
+    };
+  }
+  setState(state, opts) {
+    if (this.isDestroyed) return;
+    const filtered = ChaynsHistoryLayer.filterReservedKeys(state);
+    void this.deps.getQueue().enqueue({
+      kind: 'setState',
+      layerId: this.id,
+      state: filtered,
+      opts: opts !== null && opts !== void 0 ? opts : {}
+    });
+  }
+  navigate(opts) {
+    if (this.isDestroyed) return Promise.resolve({
+      isOk: false,
+      reason: 'destroyed'
+    });
+    const {
+      route,
+      state,
+      params,
+      hash,
+      activeChild,
+      activeChildInit,
+      ...rest
+    } = opts;
+    return this.deps.getQueue().enqueue({
+      kind: 'navigate',
+      layerId: this.id,
+      route: route !== undefined ? ChaynsHistoryLayer.normalizeRoute(route) : undefined,
+      state: state ? ChaynsHistoryLayer.filterReservedKeys(state) : undefined,
+      params,
+      hash: hash !== undefined ? hash.startsWith('#') ? hash.slice(1) : hash : undefined,
+      activeChild,
+      activeChildInit: activeChildInit ? {
+        ...activeChildInit,
+        route: activeChildInit.route !== undefined ? ChaynsHistoryLayer.normalizeRoute(activeChildInit.route) : undefined
+      } : undefined,
+      opts: rest
+    });
+  }
+  addBlock(callback, opts = {}) {
+    return this.deps.getBlockRegistry().add(this, callback, opts);
+  }
+  addEventListener(type, handler) {
+    return this.bus.on(type, handler);
+  }
+  _getOwnState() {
+    return this.ownState;
+  }
+  _getOwnSegments() {
+    return this.segments;
+  }
+  _getChildren() {
+    return this.children;
+  }
+  _setOwnStateSilent(next) {
+    this.ownState = ChaynsHistoryLayer.filterReservedKeys(next);
+  }
+  _setOwnSegmentsSilent(next) {
+    this.segments = normalizeHistorySegments(next);
+  }
+  _getOwnParams() {
+    return this._params;
+  }
+  _setOwnParamsSilent(params) {
+    this._params = {
+      ...params
+    };
+  }
+  _getOwnHash() {
+    return this._hash;
+  }
+  _setOwnHashSilent(hash) {
+    this._hash = hash;
+  }
+  _setActiveChildSilent(id) {
+    this.activeChildId = id;
+  }
+  _emit(type) {
+    var _this$_hash2;
+    const event = {
+      type,
+      layerId: this.id,
+      segments: [...this.segments],
+      state: {
+        ...this.ownState
+      },
+      params: {
+        ...this._params
+      },
+      hash: (_this$_hash2 = this._hash) !== null && _this$_hash2 !== void 0 ? _this$_hash2 : ''
+    };
+    this.bus.emit(type, event);
+  }
+  _isInActiveChain() {
+    let node = this;
+    while (node && node.parent) {
+      if (node.parent.activeChildId !== node.id) return false;
+      node = node.parent;
+    }
+    return true;
+  }
+  _setBootstrapUrlResolver(resolver) {
+    this._bootstrapUrlResolver = resolver;
+  }
+  _setBootstrapPool(segs) {
+    this._bootstrapPool = [...segs];
+  }
+  _consumeBootstrapSegments(n) {
+    if (this._bootstrapPool === null && this._bootstrapUrlResolver) {
+      const pathname = this._bootstrapUrlResolver();
+      this._bootstrapPool = pathname.replace(/^\//, '').split('/').filter(Boolean);
+      this._bootstrapUrlResolver = null;
+    }
+    if (!this._bootstrapPool || this._bootstrapPool.length === 0 || n === 0) return null;
+    const taken = this._bootstrapPool.splice(0, n);
+    while (taken.length < n) taken.push('');
+    return taken;
+  }
+  _isDestroyed() {
+    return this.isDestroyed;
+  }
+  markDestroyed() {
+    this.isDestroyed = true;
+    try {
+      this.deps.getBlockRegistry().removeAllForLayer(this.id);
+    } catch {}
+    for (const child of this.children.values()) {
+      child.markDestroyed();
+    }
+    this.children.clear();
+    this.bus.clear();
+  }
+  getCumulativeSegmentCount() {
+    let count = this.segmentCount;
+    let node = this.parent;
+    while (node) {
+      count += node.segmentCount;
+      node = node.parent;
+    }
+    return count;
+  }
+  static normalizeRoute(route) {
+    return normalizeHistoryRouteInput(route);
+  }
+  static filterReservedKeys(input) {
+    const out = {};
+    for (const key of Object.keys(input)) {
+      if (RESERVED_STATE_KEYS.includes(key)) {
+        continue;
+      }
+      out[key] = input[key];
+    }
+    return out;
+  }
+}

package/dist/esm/handler/history/index.js

@@ -0,0 +1,2 @@
+export { ChaynsHistoryLayer as ChaynsHistoryLayerClass } from './HistoryLayer';
+export { FrameHistoryLayer } from './FrameHistoryLayer';