chayns-api 3.0.0-beta.4 → 3.1.0-beta.0

package/dist/cjs/hooks/history.js

@@ -0,0 +1,454 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ChaynsHistoryLayerProvider", {
+  enumerable: true,
+  get: function () {
+    return _HistoryLayerContext.ChaynsHistoryLayerProvider;
+  }
+});
+exports.useChaynsHistoryActiveChild = useChaynsHistoryActiveChild;
+exports.useChaynsHistoryBlock = useChaynsHistoryBlock;
+exports.useChaynsHistoryChildLayer = useChaynsHistoryChildLayer;
+exports.useChaynsHistoryEvent = useChaynsHistoryEvent;
+exports.useChaynsHistoryHash = useChaynsHistoryHash;
+exports.useChaynsHistoryLayer = useChaynsHistoryLayer;
+Object.defineProperty(exports, "useChaynsHistoryLayerContext", {
+  enumerable: true,
+  get: function () {
+    return _HistoryLayerContext.useChaynsHistoryLayerContext;
+  }
+});
+exports.useChaynsHistoryNavigate = useChaynsHistoryNavigate;
+exports.useChaynsHistoryParams = useChaynsHistoryParams;
+exports.useChaynsHistoryRoute = useChaynsHistoryRoute;
+exports.useChaynsHistoryState = useChaynsHistoryState;
+var _reactCompilerRuntime = require("react-compiler-runtime");
+var _react = require("react");
+var _HistoryLayerContext = require("../contexts/HistoryLayerContext");
+var _equality = require("../utils/equality");
+function useChaynsHistoryLayer() {
+  const $ = (0, _reactCompilerRuntime.c)(1);
+  const ctx = (0, _HistoryLayerContext.useChaynsHistoryLayerContext)();
+  if (ctx) {
+    return ctx;
+  }
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    var _chaynsHost, _chaynsHost$getOwnLay;
+    t0 = typeof window !== "undefined" ? (_chaynsHost = window.__chaynsHost) === null || _chaynsHost === void 0 || (_chaynsHost = _chaynsHost.history) === null || _chaynsHost === void 0 || (_chaynsHost$getOwnLay = _chaynsHost.getOwnLayer) === null || _chaynsHost$getOwnLay === void 0 ? void 0 : _chaynsHost$getOwnLay.call(_chaynsHost) : undefined;
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const globalLayer = t0;
+  if (globalLayer) {
+    return globalLayer;
+  }
+  throw new Error("[chaynsHistory] useChaynsHistoryLayer must be used inside a <ChaynsHistoryLayerProvider>.");
+}
+function useChaynsHistoryRoute() {
+  const $ = (0, _reactCompilerRuntime.c)(10);
+  const layer = useChaynsHistoryLayer();
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = [];
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const segRef = (0, _react.useRef)(t0);
+  let t1;
+  if ($[1] !== layer) {
+    t1 = () => {
+      const next = layer.getRoute();
+      const prev = segRef.current;
+      if (prev.length === next.length && prev.every((s, i) => s === next[i])) {
+        return prev;
+      }
+      return segRef.current = next;
+    };
+    $[1] = layer;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const getSnapshot = t1;
+  let t2;
+  if ($[3] !== layer) {
+    t2 = notify => {
+      const unsub1 = layer.addEventListener("change", notify);
+      const unsub2 = layer.addEventListener("popstate", notify);
+      return () => {
+        unsub1();
+        unsub2();
+      };
+    };
+    $[3] = layer;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  const subscribe = t2;
+  const segments = (0, _react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  let t3;
+  if ($[5] !== layer) {
+    t3 = (route, opts) => layer.setRoute(route, opts);
+    $[5] = layer;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  const setRoute = t3;
+  let t4;
+  if ($[7] !== segments || $[8] !== setRoute) {
+    t4 = {
+      segments,
+      setRoute
+    };
+    $[7] = segments;
+    $[8] = setRoute;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  return t4;
+}
+function useChaynsHistoryState() {
+  const $ = (0, _reactCompilerRuntime.c)(9);
+  const layer = useChaynsHistoryLayer();
+  const stateRef = (0, _react.useRef)(undefined);
+  let t0;
+  if ($[0] !== layer) {
+    t0 = () => {
+      const next = layer.getState();
+      if (shallowEqualStateSnapshot(stateRef.current, next)) {
+        return stateRef.current;
+      }
+      return stateRef.current = next;
+    };
+    $[0] = layer;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const getSnapshot = t0;
+  let t1;
+  if ($[2] !== layer) {
+    t1 = notify => {
+      const unsub1 = layer.addEventListener("change", notify);
+      const unsub2 = layer.addEventListener("popstate", notify);
+      return () => {
+        unsub1();
+        unsub2();
+      };
+    };
+    $[2] = layer;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const subscribe = t1;
+  const state = (0, _react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  let t2;
+  if ($[4] !== layer) {
+    t2 = (s, opts) => layer.setState(s, opts);
+    $[4] = layer;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const setState = t2;
+  let t3;
+  if ($[6] !== setState || $[7] !== state) {
+    t3 = [state, setState];
+    $[6] = setState;
+    $[7] = state;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  return t3;
+}
+function useChaynsHistoryNavigate() {
+  const $ = (0, _reactCompilerRuntime.c)(2);
+  const layer = useChaynsHistoryLayer();
+  let t0;
+  if ($[0] !== layer) {
+    t0 = opts => layer.navigate(opts);
+    $[0] = layer;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+function useChaynsHistoryParams() {
+  const $ = (0, _reactCompilerRuntime.c)(10);
+  const layer = useChaynsHistoryLayer();
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = {};
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const paramsRef = (0, _react.useRef)(t0);
+  let t1;
+  if ($[1] !== layer) {
+    t1 = () => {
+      const next = layer.getParams();
+      if ((0, _equality.shallowEqualObj)(paramsRef.current, next)) {
+        return paramsRef.current;
+      }
+      return paramsRef.current = next;
+    };
+    $[1] = layer;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const getSnapshot = t1;
+  let t2;
+  if ($[3] !== layer) {
+    t2 = notify => {
+      const unsub1 = layer.addEventListener("change", notify);
+      const unsub2 = layer.addEventListener("popstate", notify);
+      return () => {
+        unsub1();
+        unsub2();
+      };
+    };
+    $[3] = layer;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  const subscribe = t2;
+  const params = (0, _react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  let t3;
+  if ($[5] !== layer) {
+    t3 = (p, opts) => layer.setParams(p, opts);
+    $[5] = layer;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  const setParams = t3;
+  let t4;
+  if ($[7] !== params || $[8] !== setParams) {
+    t4 = [params, setParams];
+    $[7] = params;
+    $[8] = setParams;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  return t4;
+}
+function useChaynsHistoryHash() {
+  const $ = (0, _reactCompilerRuntime.c)(11);
+  const layer = useChaynsHistoryLayer();
+  let t0;
+  if ($[0] !== layer) {
+    t0 = notify => {
+      const unsub1 = layer.addEventListener("change", notify);
+      const unsub2 = layer.addEventListener("popstate", notify);
+      return () => {
+        unsub1();
+        unsub2();
+      };
+    };
+    $[0] = layer;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const subscribe = t0;
+  let t1;
+  if ($[2] !== layer) {
+    t1 = () => layer.getHash();
+    $[2] = layer;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const getSnapshot = t1;
+  let t2;
+  if ($[4] !== layer) {
+    t2 = () => layer.getHash();
+    $[4] = layer;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const getServerSnapshot = t2;
+  const hash = (0, _react.useSyncExternalStore)(subscribe, getSnapshot, getServerSnapshot);
+  let t3;
+  if ($[6] !== layer) {
+    t3 = (h, opts) => layer.setHash(h, opts);
+    $[6] = layer;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  const setHash = t3;
+  let t4;
+  if ($[8] !== hash || $[9] !== setHash) {
+    t4 = [hash, setHash];
+    $[8] = hash;
+    $[9] = setHash;
+    $[10] = t4;
+  } else {
+    t4 = $[10];
+  }
+  return t4;
+}
+function useChaynsHistoryBlock(callback, t0) {
+  const $ = (0, _reactCompilerRuntime.c)(9);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === undefined ? {} : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const opts = t1;
+  const layer = useChaynsHistoryLayer();
+  const {
+    isEnabled: t2,
+    scope,
+    isBeforeUnload
+  } = opts;
+  const isEnabled = t2 === undefined ? true : t2;
+  let t3;
+  let t4;
+  if ($[2] !== callback || $[3] !== isBeforeUnload || $[4] !== isEnabled || $[5] !== layer || $[6] !== scope) {
+    t3 = () => {
+      if (!isEnabled) {
+        return;
+      }
+      return layer.addBlock(callback, {
+        scope,
+        isBeforeUnload
+      });
+    };
+    t4 = [layer, callback, isEnabled, scope, isBeforeUnload];
+    $[2] = callback;
+    $[3] = isBeforeUnload;
+    $[4] = isEnabled;
+    $[5] = layer;
+    $[6] = scope;
+    $[7] = t3;
+    $[8] = t4;
+  } else {
+    t3 = $[7];
+    t4 = $[8];
+  }
+  (0, _react.useEffect)(t3, t4);
+}
+function useChaynsHistoryEvent(type, handler) {
+  const $ = (0, _reactCompilerRuntime.c)(5);
+  const layer = useChaynsHistoryLayer();
+  let t0;
+  let t1;
+  if ($[0] !== handler || $[1] !== layer || $[2] !== type) {
+    t0 = () => layer.addEventListener(type, handler);
+    t1 = [layer, type, handler];
+    $[0] = handler;
+    $[1] = layer;
+    $[2] = type;
+    $[3] = t0;
+    $[4] = t1;
+  } else {
+    t0 = $[3];
+    t1 = $[4];
+  }
+  (0, _react.useEffect)(t0, t1);
+}
+function useChaynsHistoryChildLayer(id) {
+  const $ = (0, _reactCompilerRuntime.c)(6);
+  const layer = useChaynsHistoryLayer();
+  let t0;
+  if ($[0] !== id || $[1] !== layer) {
+    t0 = layer.getChildLayer(id);
+    $[0] = id;
+    $[1] = layer;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  let child = t0;
+  if (!child) {
+    let t1;
+    if ($[3] !== id || $[4] !== layer) {
+      t1 = layer.createChildLayer(id);
+      $[3] = id;
+      $[4] = layer;
+      $[5] = t1;
+    } else {
+      t1 = $[5];
+    }
+    child = t1;
+  }
+  return child;
+}
+function useChaynsHistoryActiveChild() {
+  const $ = (0, _reactCompilerRuntime.c)(9);
+  const layer = useChaynsHistoryLayer();
+  let t0;
+  if ($[0] !== layer) {
+    t0 = notify => layer.addEventListener("change", notify);
+    $[0] = layer;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const subscribe = t0;
+  let t1;
+  if ($[2] !== layer) {
+    t1 = () => layer.getActiveChildId();
+    $[2] = layer;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const getSnapshot = t1;
+  const activeChildId = (0, _react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  let t2;
+  if ($[4] !== layer) {
+    t2 = (id, init) => layer.setActiveChild(id, init);
+    $[4] = layer;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const setActiveChild = t2;
+  let t3;
+  if ($[6] !== activeChildId || $[7] !== setActiveChild) {
+    t3 = {
+      activeChildId,
+      setActiveChild
+    };
+    $[6] = activeChildId;
+    $[7] = setActiveChild;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  return t3;
+}
+function shallowEqualStateSnapshot(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  for (const k of ak) {
+    if (a[k] !== b[k]) return false;
+  }
+  return true;
+}

package/dist/cjs/hooks/index.js

@@ -21,6 +21,66 @@ Object.defineProperty(exports, "useChaynsApiId", {
     return _useChaynsApiId.useChaynsApiId;
   }
 });
+Object.defineProperty(exports, "useChaynsHistoryActiveChild", {
+  enumerable: true,
+  get: function () {
+    return _history.useChaynsHistoryActiveChild;
+  }
+});
+Object.defineProperty(exports, "useChaynsHistoryBlock", {
+  enumerable: true,
+  get: function () {
+    return _history.useChaynsHistoryBlock;
+  }
+});
+Object.defineProperty(exports, "useChaynsHistoryChildLayer", {
+  enumerable: true,
+  get: function () {
+    return _history.useChaynsHistoryChildLayer;
+  }
+});
+Object.defineProperty(exports, "useChaynsHistoryEvent", {
+  enumerable: true,
+  get: function () {
+    return _history.useChaynsHistoryEvent;
+  }
+});
+Object.defineProperty(exports, "useChaynsHistoryHash", {
+  enumerable: true,
+  get: function () {
+    return _history.useChaynsHistoryHash;
+  }
+});
+Object.defineProperty(exports, "useChaynsHistoryLayer", {
+  enumerable: true,
+  get: function () {
+    return _history.useChaynsHistoryLayer;
+  }
+});
+Object.defineProperty(exports, "useChaynsHistoryNavigate", {
+  enumerable: true,
+  get: function () {
+    return _history.useChaynsHistoryNavigate;
+  }
+});
+Object.defineProperty(exports, "useChaynsHistoryParams", {
+  enumerable: true,
+  get: function () {
+    return _history.useChaynsHistoryParams;
+  }
+});
+Object.defineProperty(exports, "useChaynsHistoryRoute", {
+  enumerable: true,
+  get: function () {
+    return _history.useChaynsHistoryRoute;
+  }
+});
+Object.defineProperty(exports, "useChaynsHistoryState", {
+  enumerable: true,
+  get: function () {
+    return _history.useChaynsHistoryState;
+  }
+});
 Object.defineProperty(exports, "useCurrentPage", {
   enumerable: true,
   get: function () {
@@ -197,4 +257,5 @@ var _useDialogState = require("./useDialogState");
 var _useCustomCallbackFunction = require("./useCustomCallbackFunction");
 var _useCustomFunction = require("./useCustomFunction");
 var _useStyleSettings = require("./useStyleSettings");
-var _useChaynsApiId = require("./useChaynsApiId");
+var _useChaynsApiId = require("./useChaynsApiId");
+var _history = require("./history");