chayns-api 3.0.0 → 3.1.0-beta.0

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

@@ -0,0 +1,321 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChaynsHistoryLayer = void 0;
+var _EventBus = require("../../utils/EventBus");
+var _rootLayer = require("../../utils/history/rootLayer");
+var _segments = require("../../utils/history/segments");
+const RESERVED_STATE_KEYS = ['activeChild', 'childState', '__params', '__hash'];
+class ChaynsHistoryLayer {
+  children = new Map();
+  activeChildId = null;
+  segmentCount = 0;
+  segments = [];
+  ownState = {};
+  _params = {};
+  _hash = undefined;
+  bus = new _EventBus.EventBus();
+  _bootstrapPool = null;
+  _bootstrapUrlResolver = null;
+  isDestroyed = false;
+  constructor(init) {
+    var _init$segmentCount, _init$segments;
+    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 = (0, _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 = (0, _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 = (0, _rootLayer.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 = (0, _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 (0, _segments.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;
+  }
+}
+exports.ChaynsHistoryLayer = ChaynsHistoryLayer;

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

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ChaynsHistoryLayerClass", {
+  enumerable: true,
+  get: function () {
+    return _HistoryLayer.ChaynsHistoryLayer;
+  }
+});
+Object.defineProperty(exports, "FrameHistoryLayer", {
+  enumerable: true,
+  get: function () {
+    return _FrameHistoryLayer.FrameHistoryLayer;
+  }
+});
+var _HistoryLayer = require("./HistoryLayer");
+var _FrameHistoryLayer = require("./FrameHistoryLayer");