one/dist/cjs/fork/useLinking.native.test.native.js

One is a new React Framework that makes Vite serve both native and web.

"use strict";

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
  value: mod,
  enumerable: true
}) : target, mod));
var import_jsx_runtime = require("react/jsx-runtime");
var import_react = __toESM(require("react"), 1);
var import_react_test_renderer = __toESM(require("react-test-renderer"), 1);
var import_vitest = require("vitest");
var import_getLinkingConfig = require("../router/getLinkingConfig.native.js");
var import_getRoutes = require("../router/getRoutes.native.js");
var import_testing_utils = require("../testing-utils.native.js");
var import_getStateFromPath = require("./getStateFromPath.native.js");
var import_useLinking = require("./useLinking.native");
globalThis.IS_REACT_ACT_ENVIRONMENT = true;
var linking = (0, import_getLinkingConfig.getLinkingConfig)((0, import_getRoutes.getRoutes)((0, import_testing_utils.getMockContext)(["_layout.tsx", "home/_layout.tsx", "home/[projectId]/_layout.tsx", "home/[projectId]/index.tsx", "settings.tsx"])));
var config = linking.config;
var currentState = {
  stale: false,
  type: "stack",
  key: "root-stack",
  index: 1,
  routeNames: ["home", "settings"],
  routes: [{
    name: "home",
    key: "home-travelo",
    params: {
      projectId: "proj_example_travelo"
    },
    state: {
      stale: false,
      type: "stack",
      key: "home-stack",
      index: 0,
      routeNames: ["[projectId]"],
      routes: [{
        name: "[projectId]",
        key: "project-travelo",
        params: {
          projectId: "proj_example_travelo"
        }
      }]
    }
  }, {
    name: "settings",
    key: "settings"
  }]
};
async function captureIncomingAction() {
  var overrides = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
  var _dispatch_mock_calls_;
  var linkedState = (0, import_getStateFromPath.getStateFromPath)("/home/proj_example_pennywise?tab=design", config);
  var dispatch = import_vitest.vi.fn();
  var listener;
  var navigation = {
    dispatch,
    getRootState: function () {
      return currentState;
    }
  };
  var ref = {
    current: navigation
  };
  function Harness() {
    (0, import_useLinking.useLinking)(ref, {
      ...linking,
      enabled: true,
      prefixes: ["contrast:///"],
      getInitialURL: function () {
        return null;
      },
      getStateFromPath: function () {
        return linkedState;
      },
      subscribe: function (nextListener) {
        listener = nextListener;
        return function () {};
      },
      ...overrides
    }, function () {});
    return null;
  }
  var renderer;
  await (0, import_react_test_renderer.act)(async function () {
    renderer = import_react_test_renderer.default.create(/* @__PURE__ */(0, import_jsx_runtime.jsx)(Harness, {}));
  });
  (0, import_react_test_renderer.act)(function () {
    return listener("contrast:///home/proj_example_pennywise?tab=design");
  });
  return {
    action: (_dispatch_mock_calls_ = dispatch.mock.calls[0]) === null || _dispatch_mock_calls_ === void 0 ? void 0 : _dispatch_mock_calls_[0],
    linkedState,
    renderer
  };
}
(0, import_vitest.afterEach)(function () {
  import_vitest.vi.restoreAllMocks();
});
(0, import_vitest.describe)("native incoming links", function () {
  (0, import_vitest.it)("applies every nested dynamic param when leaving a sibling route", async function () {
    var {
      action,
      renderer
    } = await captureIncomingAction();
    (0, import_vitest.expect)(action).toStrictEqual({
      type: "NAVIGATE",
      target: "root-stack",
      payload: {
        key: void 0,
        name: "home",
        params: {
          projectId: "proj_example_pennywise",
          screen: "[projectId]",
          params: {
            projectId: "proj_example_pennywise",
            tab: "design",
            screen: "index",
            params: {
              projectId: "proj_example_pennywise",
              tab: "design"
            }
          }
        }
      }
    });
    (0, import_react_test_renderer.act)(function () {
      return renderer.unmount();
    });
  });
  (0, import_vitest.it)("keeps a configured getActionFromState in control", async function () {
    var customAction = {
      type: "NAVIGATE",
      payload: {
        name: "custom"
      }
    };
    var getActionFromState = import_vitest.vi.fn(function (_state) {
      return customAction;
    });
    var {
      action,
      linkedState,
      renderer
    } = await captureIncomingAction({
      getActionFromState
    });
    (0, import_vitest.expect)(action).toBe(customAction);
    (0, import_vitest.expect)(getActionFromState).toHaveBeenCalledOnce();
    (0, import_vitest.expect)(getActionFromState.mock.calls[0][0]).toEqual({
      ...linkedState,
      routes: [import_vitest.expect.not.objectContaining({
        key: import_vitest.expect.anything()
      })]
    });
    (0, import_react_test_renderer.act)(function () {
      return renderer.unmount();
    });
  });
});
//# sourceMappingURL=useLinking.native.test.native.js.map