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

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

import { jsx as _jsx } from "react/jsx-runtime";
import React from "react";
import TestRenderer, { act } from "react-test-renderer";
import { afterEach, describe, expect, it, vi } from "vitest";
import { getLinkingConfig } from "../router/getLinkingConfig.native.js";
import { getRoutes } from "../router/getRoutes.native.js";
import { getMockContext } from "../testing-utils.native.js";
import { getStateFromPath } from "./getStateFromPath.native.js";
import { useLinking } from "./useLinking.native.native.js";
globalThis.IS_REACT_ACT_ENVIRONMENT = true;
var linking = getLinkingConfig(getRoutes(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 = getStateFromPath("/home/proj_example_pennywise?tab=design", config);
  var dispatch = vi.fn();
  var listener;
  var navigation = {
    dispatch,
    getRootState: function () {
      return currentState;
    }
  };
  var ref = {
    current: navigation
  };
  function Harness() {
    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 act(async function () {
    renderer = TestRenderer.create(/* @__PURE__ */_jsx(Harness, {}));
  });
  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
  };
}
afterEach(function () {
  vi.restoreAllMocks();
});
describe("native incoming links", function () {
  it("applies every nested dynamic param when leaving a sibling route", async function () {
    var {
      action,
      renderer
    } = await captureIncomingAction();
    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"
            }
          }
        }
      }
    });
    act(function () {
      return renderer.unmount();
    });
  });
  it("keeps a configured getActionFromState in control", async function () {
    var customAction = {
      type: "NAVIGATE",
      payload: {
        name: "custom"
      }
    };
    var getActionFromState = vi.fn(function (_state) {
      return customAction;
    });
    var {
      action,
      linkedState,
      renderer
    } = await captureIncomingAction({
      getActionFromState
    });
    expect(action).toBe(customAction);
    expect(getActionFromState).toHaveBeenCalledOnce();
    expect(getActionFromState.mock.calls[0][0]).toEqual({
      ...linkedState,
      routes: [expect.not.objectContaining({
        key: expect.anything()
      })]
    });
    act(function () {
      return renderer.unmount();
    });
  });
});
//# sourceMappingURL=useLinking.native.test.native.js.map