one
Version:
One is a new React Framework that makes Vite serve both native and web.
150 lines • 6.78 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all) __defProp(target, name, {
get: all[name],
enumerable: !0
});
},
__copyProps = (to, from, except, desc) => {
if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
get: () => from[key],
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
});
return to;
};
var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
value: !0
}), mod);
var common_exports = {};
__export(common_exports, {
ViewSlot: () => ViewSlot,
stateToAction: () => stateToAction,
triggersToScreens: () => triggersToScreens
});
module.exports = __toCommonJS(common_exports);
var import_href = require("../link/href.cjs"),
import_sortRoutes = require("../router/sortRoutes.cjs"),
import_Slot = require("./Slot.cjs"),
import_useScreens = require("../router/useScreens.cjs"),
import_jsx_runtime = require("react/jsx-runtime");
const ViewSlot = import_Slot.Slot;
function resolveHrefWithSegments(href, routeInfo, segmentsWithoutGroups) {
if (href.startsWith("./") || href.startsWith("../")) {
const parts = ((("/" + segmentsWithoutGroups.join("/")).replace(/\/[^/]*$/, "") || "/") + "/" + href).split("/"),
resolved = [];
for (const part of parts) part === "." || part === "" || (part === ".." ? resolved.pop() : resolved.push(part));
return "/" + resolved.join("/");
}
return href;
}
function triggersToScreens(triggers, layoutRouteNode, linking, initialRouteName, parentTriggerMap, routeInfo, contextKey) {
const configs = [];
for (const trigger of triggers) {
if (trigger.name in parentTriggerMap) {
const parentTrigger = parentTriggerMap[trigger.name];
throw new Error(`Trigger ${JSON.stringify({
name: trigger.name,
href: trigger.href
})} has the same name as parent trigger ${JSON.stringify({
name: parentTrigger.name,
href: parentTrigger.href
})}. Triggers must have unique names.`);
}
if (trigger.type === "external") {
configs.push(trigger);
continue;
}
let resolvedHref = (0, import_href.resolveHref)(trigger.href);
if (resolvedHref.startsWith("../")) throw new Error("Trigger href cannot link to a parent directory");
const segmentsWithoutGroups = contextKey.split("/").filter(segment => !(segment.startsWith("(") && segment.endsWith(")")));
resolvedHref = resolveHrefWithSegments(resolvedHref, routeInfo, segmentsWithoutGroups);
let state = linking.getStateFromPath?.(resolvedHref, linking.config)?.routes[0];
if (!state) {
console.warn(`Unable to find screen for trigger ${JSON.stringify(trigger)}. Does this point to a valid screen?`);
continue;
}
let routeState = state;
if (routeState.name === "+not-found") {
process.env.NODE_ENV !== "production" && console.warn(`Tab trigger '${trigger.name}' has the href '${trigger.href}' which points to a +not-found route.`);
continue;
}
const targetStateName = layoutRouteNode.route || "__root";
for (; state?.state && state.name !== targetStateName;) state = state.state.routes[state.state.index ?? state.state.routes.length - 1];
routeState = state.state?.routes[state.state.index ?? state.state.routes.length - 1] || state;
const routeNode = layoutRouteNode.children.find(child => child.route === routeState?.name);
if (!routeNode) {
console.warn(`Unable to find routeNode for trigger ${JSON.stringify(trigger)}. This might be a bug in One router`);
continue;
}
const duplicateTrigger = trigger.type === "internal" && configs.find(config => config.type === "external" ? !1 : config.routeNode.route === routeNode.route);
if (duplicateTrigger) {
const duplicateTriggerText = `${JSON.stringify({
name: duplicateTrigger.name,
href: duplicateTrigger.href
})} and ${JSON.stringify({
name: trigger.name,
href: trigger.href
})}`;
throw new Error(`A navigator cannot contain multiple trigger components that map to the same sub-segment. Consider adding a shared group and assigning a group to each trigger. Conflicting triggers:
${duplicateTriggerText}.
Both triggers map to route ${routeNode.route}.`);
}
configs.push({
...trigger,
href: resolvedHref,
routeNode,
action: stateToAction(state, layoutRouteNode.route)
});
}
const sortFn = (0, import_sortRoutes.sortRoutesWithInitial)(initialRouteName),
sortedConfigs = configs.sort((a, b) => a.type === "external" && b.type === "external" ? 0 : a.type === "external" ? 1 : b.type === "external" ? -1 : sortFn(a.routeNode, b.routeNode)),
children = [],
triggerMap = {
...parentTriggerMap
};
for (const [index, config] of sortedConfigs.entries()) if (triggerMap[config.name] = {
...config,
index
}, config.type === "internal") {
const route = config.routeNode;
children.push(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_useScreens.Screen, {
getId: (0, import_useScreens.createGetIdForRoute)(route),
name: route.route,
options: args => {
const staticOptions = route.generated ? route.loadRoute()?.getNavOptions : null,
output = {
...(typeof staticOptions == "function" ? staticOptions(args) : staticOptions)
};
return route.generated && (output.tabBarButton = () => null, output.drawerItemStyle = {
height: 0,
display: "none"
}), output;
},
getComponent: () => (0, import_useScreens.getQualifiedRouteComponent)(route)
}, route.route));
}
return {
children,
triggerMap
};
}
function stateToAction(state, startAtRoute) {
const rootPayload = {};
let payload = rootPayload;
startAtRoute = startAtRoute === "" ? "__root" : startAtRoute;
let foundStartingPoint = startAtRoute === void 0 || !state?.state;
for (; state;) if (foundStartingPoint) payload === rootPayload ? payload.name = state.name : payload.screen = state.name, payload.params = state.params ? {
...state.params
} : {}, state = state.state?.routes[state.state?.routes.length - 1], state && (payload.params ??= {}, payload = payload.params);else {
state.name === startAtRoute && (foundStartingPoint = !0);
const nextState = state.state?.routes[state.state?.routes.length - 1];
nextState && (state = nextState);
}
return {
type: "JUMP_TO",
payload: rootPayload
};
}