chayns-api 3.0.0 → 3.1.0-beta.0

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