520 lines
16 KiB
JavaScript
520 lines
16 KiB
JavaScript
// Module ID: 1500
|
|
// Function ID: 17282
|
|
// Name: joinPaths
|
|
// Dependencies: [77, 65, 1493, 1501, 1475, 1495]
|
|
// Exports: default
|
|
|
|
// Module 1500 (joinPaths)
|
|
import _defineProperty from "_defineProperty";
|
|
import _toConsumableArray from "_toConsumableArray";
|
|
|
|
function joinPaths() {
|
|
const length = arguments.length;
|
|
const arr = new Array(length);
|
|
for (let num = 0; num < length; num = num + 1) {
|
|
arr[num] = arguments[num];
|
|
}
|
|
const items = [];
|
|
const concat = items.concat;
|
|
const found = concat.apply(items, callback(arr.map((str) => str.split("/")))).filter(Boolean);
|
|
return found.join("/");
|
|
}
|
|
function matchAgainstConfigs(arg0, sorted) {
|
|
let closure_0 = sorted;
|
|
let closure_2 = arg0;
|
|
function _loop() {
|
|
if (_defineProperty.regex) {
|
|
const match = closure_2.match(_defineProperty.regex);
|
|
if (match) {
|
|
let reduced;
|
|
if (null != _defineProperty.pattern) {
|
|
let parts = str.split("/");
|
|
let found = parts.filter((str) => str.startsWith(":"));
|
|
reduced = found.reduce((arg0, arg1, arg2) => Object.assign(arg0, callback({}, arg1, match[2 * (arg2 + 1)].replace(/\//, ""))), {});
|
|
}
|
|
let closure_1 = reduced;
|
|
const routeNames = _defineProperty.routeNames;
|
|
closure_1 = routeNames.map((name) => {
|
|
let closure_0 = name;
|
|
const found = match.find((screen) => screen.screen === closure_0);
|
|
let reduced;
|
|
if (null != found) {
|
|
if (null != found.path) {
|
|
const parts = str.split("/");
|
|
const found1 = parts.filter((str) => str.startsWith(":"));
|
|
reduced = found1.reduce((arg0, str) => {
|
|
if (found[str]) {
|
|
const replaced = str.replace(/^:/, "").replace(/\?$/, "");
|
|
const parse = found.parse;
|
|
let tmp5 = tmp;
|
|
if (null != parse) {
|
|
tmp5 = tmp;
|
|
if (parse[replaced]) {
|
|
const parse2 = found.parse;
|
|
tmp5 = parse2[replaced](tmp);
|
|
}
|
|
}
|
|
arg0[replaced] = tmp5;
|
|
const str2 = str.replace(/^:/, "");
|
|
}
|
|
return arg0;
|
|
}, {});
|
|
}
|
|
}
|
|
if (reduced) {
|
|
const _Object = Object;
|
|
if (Object.keys(reduced).length) {
|
|
let obj = { name, params: reduced };
|
|
}
|
|
return obj;
|
|
}
|
|
obj = { name };
|
|
});
|
|
closure_2 = closure_2.replace(match[1], "");
|
|
return 1;
|
|
}
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
const iter = sorted[Symbol.iterator]();
|
|
while (iter !== undefined) {
|
|
let _defineProperty = iter.next();
|
|
let tmp = _loop;
|
|
let _loopResult = _loop();
|
|
if (0 !== _loopResult) {
|
|
let tmp4 = _loopResult;
|
|
if (1 === tmp3) {
|
|
iter.return();
|
|
break;
|
|
}
|
|
let obj = {};
|
|
let tmp5 = importAll;
|
|
obj.routes = importAll;
|
|
let tmp6 = closure_2;
|
|
obj.remainingPath = closure_2;
|
|
return obj;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
function createNormalizedConfigs(arg0, arg1) {
|
|
if (arguments.length > 2) {
|
|
if (undefined !== arguments[2]) {
|
|
let items1 = arguments[2];
|
|
}
|
|
let tmp;
|
|
if (arguments.length > 3) {
|
|
tmp = arguments[3];
|
|
}
|
|
const importAll = tmp;
|
|
let tmp2;
|
|
if (arguments.length > 4) {
|
|
tmp2 = arguments[4];
|
|
}
|
|
const dependencyMap = tmp2;
|
|
let tmp3;
|
|
if (arguments.length > 5) {
|
|
tmp3 = arguments[5];
|
|
}
|
|
let _defineProperty = tmp3;
|
|
const items = [];
|
|
items1.push(arg0);
|
|
tmp2.push(arg0);
|
|
const joinPaths = tmp7;
|
|
if ("string" === typeof arg1[arg0]) {
|
|
let tmp25 = tmp7;
|
|
if (tmp3) {
|
|
tmp25 = joinPaths(tmp3, tmp7);
|
|
}
|
|
items.push(createConfigItem(arg0, items1, tmp25, tmp7));
|
|
} else if ("object" === tmp8) {
|
|
if ("string" !== typeof tmp7.path) {
|
|
if (tmp7.screens) {
|
|
if (tmp7.initialRouteName) {
|
|
const obj = { initialRouteName: tmp7.initialRouteName, parentScreens: tmp2 };
|
|
tmp.push(obj);
|
|
}
|
|
const _Object = Object;
|
|
const keys = Object.keys(tmp7.screens);
|
|
const item = keys.forEach((arg0) => {
|
|
const push = items.push;
|
|
push.apply(items, items(outer1_7(arg0, tmp7.screens, items1, closure_1, items(closure_2), null != closure_6 ? closure_6 : _defineProperty)));
|
|
});
|
|
}
|
|
} else {
|
|
if (tmp7.exact) {
|
|
if (undefined === tmp7.path) {
|
|
const _Error = Error;
|
|
const error = new Error("A 'path' needs to be specified when specifying 'exact: true'. If you don't want this screen in the URL, specify it as empty string, e.g. `path: ''`.");
|
|
throw error;
|
|
}
|
|
}
|
|
if (true !== tmp7.exact) {
|
|
let str2 = tmp3;
|
|
if (!tmp3) {
|
|
str2 = "";
|
|
}
|
|
let tmp10Result = joinPaths(str2, tmp7.path || "");
|
|
const tmp10 = joinPaths;
|
|
const tmp11 = tmp7.path || "";
|
|
} else {
|
|
tmp10Result = tmp7.path || "";
|
|
}
|
|
const matchAgainstConfigs = tmp10Result;
|
|
items.push(createConfigItem(arg0, items1, tmp10Result, tmp7.path, tmp7.parse));
|
|
}
|
|
}
|
|
items1.pop();
|
|
return items;
|
|
}
|
|
items1 = [];
|
|
}
|
|
function createConfigItem(screen, arg1, str, path, parse) {
|
|
const obj = { screen };
|
|
const parts = str.split("/");
|
|
const found = parts.filter(Boolean);
|
|
str = found.join("/");
|
|
let regExp;
|
|
if (str) {
|
|
const _RegExp = RegExp;
|
|
const parts1 = str.split("/");
|
|
const mapped = parts1.map((str) => {
|
|
if (str.startsWith(":")) {
|
|
let str6 = "";
|
|
if (str.endsWith("?")) {
|
|
str6 = "?";
|
|
}
|
|
const _HermesInternal2 = HermesInternal;
|
|
let combined = "(([^/]+\\/)" + str6 + ")";
|
|
} else {
|
|
str = ".*";
|
|
if ("*" !== str) {
|
|
str = outer1_0(outer1_2[3])(str);
|
|
}
|
|
const _HermesInternal = HermesInternal;
|
|
combined = "" + str + "\\/";
|
|
}
|
|
return combined;
|
|
});
|
|
let _HermesInternal = HermesInternal;
|
|
regExp = new RegExp("^(" + mapped.join("") + ")");
|
|
}
|
|
obj.regex = regExp;
|
|
obj.pattern = str;
|
|
obj.path = path;
|
|
obj.routeNames = callback(arg1);
|
|
obj.parse = parse;
|
|
return obj;
|
|
}
|
|
function findInitialRoute(name, items, items) {
|
|
const iter = items[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
let tmp13 = nextResult;
|
|
let tmp14 = items;
|
|
if (items.length === nextResult.parentScreens.length) {
|
|
let flag = true;
|
|
let num = 0;
|
|
let tmp2 = items;
|
|
if (0 < items.length) {
|
|
let tmp3 = items;
|
|
let tmp4 = num;
|
|
let obj = items[num];
|
|
let tmp5 = nextResult;
|
|
while (0 === obj.localeCompare(tmp13.parentScreens[num])) {
|
|
let tmp6 = num;
|
|
let sum = num + 1;
|
|
num = sum;
|
|
let tmp8 = items;
|
|
}
|
|
flag = false;
|
|
}
|
|
let tmp9 = flag;
|
|
if (flag) {
|
|
let tmp10 = name;
|
|
let tmp11 = nextResult;
|
|
let initialRouteName;
|
|
if (name !== tmp13.initialRouteName) {
|
|
initialRouteName = nextResult.initialRouteName;
|
|
}
|
|
iter.return();
|
|
return initialRouteName;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
function createStateObject(arg0, arr, arg2) {
|
|
let items = arg0;
|
|
let obj = {};
|
|
if (arg2) {
|
|
if (items) {
|
|
obj = { index: 1, name: items };
|
|
items = [obj, arr];
|
|
obj.routes = items;
|
|
let tmp4 = obj;
|
|
} else {
|
|
const items1 = [arr];
|
|
obj.routes = items1;
|
|
tmp4 = obj;
|
|
}
|
|
} else {
|
|
if (items) {
|
|
obj = { index: 1, name: items };
|
|
const items2 = [obj, ];
|
|
const _Object2 = Object;
|
|
const obj1 = {};
|
|
const obj2 = { routes: [] };
|
|
obj1.state = obj2;
|
|
items2[1] = Object.assign({}, arr, obj1);
|
|
obj.routes = items2;
|
|
let tmp2 = obj;
|
|
} else {
|
|
const _Object = Object;
|
|
const obj3 = {};
|
|
const obj4 = { routes: [] };
|
|
obj3.state = obj4;
|
|
const items3 = [Object.assign({}, arr, obj3)];
|
|
obj.routes = items3;
|
|
tmp2 = obj;
|
|
}
|
|
return tmp2;
|
|
}
|
|
}
|
|
function createNestedStateObject(path, mapped, items, sorted) {
|
|
let arr = mapped.shift();
|
|
items = [];
|
|
arr = items.push(arr.name);
|
|
const tmp4 = createStateObject(findInitialRoute(arr.name, items, items), arr, 0 === mapped.length);
|
|
if (mapped.length > 0) {
|
|
let arr1 = mapped.shift();
|
|
let tmp10 = tmp4;
|
|
while (arr1) {
|
|
let tmp5 = findInitialRoute;
|
|
let index = tmp10.index;
|
|
let tmp6 = findInitialRoute(arr1.name, items, items);
|
|
if (!index) {
|
|
index = tmp10.routes.length - 1;
|
|
}
|
|
let tmp7 = createStateObject;
|
|
tmp10.routes[index].state = createStateObject(tmp6, arr1, 0 === mapped.length);
|
|
let state = tmp10;
|
|
if (mapped.length > 0) {
|
|
state = tmp10.routes[index].state;
|
|
}
|
|
let arr2 = items.push(arr1.name);
|
|
arr1 = mapped.shift();
|
|
tmp10 = state;
|
|
}
|
|
}
|
|
const tmp11 = importDefault(1475)(tmp4);
|
|
tmp11.path = path;
|
|
if (!sorted) {
|
|
const tmp20 = parseQueryParams(path, undefined);
|
|
if (tmp20) {
|
|
const _Object = Object;
|
|
tmp11.params = Object.assign({}, tmp11.params, tmp20);
|
|
}
|
|
return tmp4;
|
|
} else {
|
|
const name = tmp11.name;
|
|
const iter = sorted[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
let tmp16 = nextResult;
|
|
let tmp17 = name;
|
|
if (tmp12 === nextResult.routeNames[nextResult.routeNames.length - 1]) {
|
|
iter.return();
|
|
let parse = nextResult.parse;
|
|
break;
|
|
}
|
|
let tmp19 = parse;
|
|
let tmp18 = __exception;
|
|
iter.return();
|
|
throw tmp18;
|
|
}
|
|
tmp12 = name;
|
|
}
|
|
}
|
|
function parseQueryParams(path, arg1) {
|
|
let closure_0 = arg1;
|
|
parsed = parsed(1495).parse(path.split("?")[1]);
|
|
if (arg1) {
|
|
const _Object = Object;
|
|
const keys = Object.keys(parsed);
|
|
const item = keys.forEach((arg0) => {
|
|
let callResult = hasOwnProperty.call(dependencyMap, arg0);
|
|
if (callResult) {
|
|
callResult = "string" === typeof parsed[arg0];
|
|
}
|
|
if (callResult) {
|
|
parsed[arg0] = dependencyMap[arg0](parsed[arg0]);
|
|
}
|
|
});
|
|
}
|
|
let tmp4;
|
|
if (Object.keys(parsed).length) {
|
|
tmp4 = parsed;
|
|
}
|
|
return tmp4;
|
|
}
|
|
|
|
export default function getStateFromPath(path, config) {
|
|
let remainingPath;
|
|
let routes;
|
|
if (config) {
|
|
items(sorted[2])(config);
|
|
}
|
|
items = [];
|
|
if (tmp4) {
|
|
let obj = { initialRouteName: config.initialRouteName, parentScreens: [] };
|
|
items.push(obj);
|
|
}
|
|
let screens;
|
|
if (null != config) {
|
|
screens = config.screens;
|
|
}
|
|
const str = path.replace(/\/+/g, "/");
|
|
tmp4 = null != config && config.initialRouteName;
|
|
const replaced = path.replace(/\/+/g, "/").replace(/^\//, "").replace(/\?.*$/, "");
|
|
let str3 = replaced;
|
|
if (!replaced.endsWith("/")) {
|
|
let _HermesInternal = HermesInternal;
|
|
str3 = "" + replaced + "/";
|
|
}
|
|
if (undefined === screens) {
|
|
let parts = str3.split("/");
|
|
const _Boolean = Boolean;
|
|
let found = parts.filter(Boolean);
|
|
const mapped = found.map((arg0) => ({ name: decodeURIComponent(arg0) }));
|
|
let tmp24;
|
|
if (mapped.length) {
|
|
tmp24 = createNestedStateObject(path, mapped, items);
|
|
}
|
|
return tmp24;
|
|
} else {
|
|
const items1 = [];
|
|
const concat = items1.concat;
|
|
const _Object = Object;
|
|
const keys = Object.keys(screens);
|
|
sorted = concat.apply(items1, callback(keys.map((arg0) => outer1_7(arg0, screens, [], items, [])))).sort((pattern, pattern2) => {
|
|
if (pattern.pattern === pattern2.pattern) {
|
|
const routeNames = pattern2.routeNames;
|
|
const joined = routeNames.join(">");
|
|
const routeNames2 = pattern.routeNames;
|
|
return joined.localeCompare(routeNames2.join(">"));
|
|
} else {
|
|
pattern2 = pattern.pattern;
|
|
if (pattern2.startsWith(pattern2.pattern)) {
|
|
return -1;
|
|
} else {
|
|
pattern = pattern2.pattern;
|
|
if (pattern.startsWith(pattern.pattern)) {
|
|
return 1;
|
|
} else {
|
|
const parts = pattern.pattern.split("/");
|
|
const parts1 = pattern2.pattern.split("/");
|
|
const _Math = Math;
|
|
let num = 0;
|
|
if (0 < Math.max(parts.length, parts1.length)) {
|
|
while (null != parts[num]) {
|
|
if (null == parts1[num]) {
|
|
let num4 = -1;
|
|
return -1;
|
|
} else {
|
|
let startsWithResult = "*" === parts[num];
|
|
if (!startsWithResult) {
|
|
let obj = parts[num];
|
|
startsWithResult = obj.startsWith(":");
|
|
}
|
|
let startsWithResult1 = "*" === parts1[num];
|
|
if (!startsWithResult1) {
|
|
let obj2 = parts1[num];
|
|
startsWithResult1 = obj2.startsWith(":");
|
|
}
|
|
if (!startsWithResult) {
|
|
if (startsWithResult) {
|
|
let num3 = 1;
|
|
return 1;
|
|
} else if (startsWithResult1) {
|
|
let num2 = -1;
|
|
return -1;
|
|
}
|
|
}
|
|
num = num + 1;
|
|
let _Math2 = Math;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
return parts1.length - parts.length;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
const reduced = sorted.reduce((arg0, routeNames) => {
|
|
if (arg0[routeNames.pattern]) {
|
|
routeNames = arg0[routeNames.pattern].routeNames;
|
|
const routeNames1 = routeNames.routeNames;
|
|
if (routeNames.length > routeNames1.length) {
|
|
let everyResult = routeNames1.every((arg0, arg1) => routeNames[arg1] === arg0);
|
|
} else {
|
|
everyResult = routeNames.every((arg0, arg1) => routeNames1[arg1] === arg0);
|
|
}
|
|
if (!everyResult) {
|
|
const _Error = Error;
|
|
const pattern = routeNames.pattern;
|
|
const joined = routeNames.join(" > ");
|
|
const _HermesInternal = HermesInternal;
|
|
const error = new Error("Found conflicting screens with the same pattern. The pattern '" + pattern + "' resolves to both '" + joined + "' and '" + routeNames1.join(" > ") + "'. Patterns must be unique and cannot resolve to more than one screen.");
|
|
throw error;
|
|
}
|
|
}
|
|
return Object.assign(arg0, outer1_3({}, routeNames.pattern, routeNames));
|
|
}, {});
|
|
if ("/" === str3) {
|
|
const found1 = sorted.find((path) => {
|
|
let everyResult = "" === path.path;
|
|
if (everyResult) {
|
|
const routeNames = path.routeNames;
|
|
everyResult = routeNames.every((arg0) => {
|
|
let closure_0 = arg0;
|
|
const found = outer1_2.find((screen) => screen.screen === closure_0);
|
|
return !(null != found && found.path);
|
|
});
|
|
}
|
|
return everyResult;
|
|
});
|
|
let tmp18;
|
|
if (found1) {
|
|
let routeNames = found1.routeNames;
|
|
tmp18 = createNestedStateObject(path, routeNames.map((name) => ({ name })), items, sorted);
|
|
}
|
|
return tmp18;
|
|
} else {
|
|
({ routes, remainingPath } = matchAgainstConfigs(str3, sorted.map((regex) => {
|
|
const obj = {};
|
|
let regExp;
|
|
if (regex.regex) {
|
|
const _RegExp = RegExp;
|
|
regExp = new RegExp(regex.regex.source + "$");
|
|
}
|
|
obj.regex = regExp;
|
|
return Object.assign({}, regex, obj);
|
|
})));
|
|
let tmp11;
|
|
if (undefined !== routes) {
|
|
const tmp10 = createNestedStateObject(path, routes, items, sorted);
|
|
tmp11 = tmp10;
|
|
}
|
|
if (null != tmp11) {
|
|
if (null != tmp10) {
|
|
return tmp10;
|
|
}
|
|
}
|
|
}
|
|
const applyResult = concat.apply(items1, callback(keys.map((arg0) => outer1_7(arg0, screens, [], items, []))));
|
|
}
|
|
const str2 = path.replace(/\/+/g, "/").replace(/^\//, "");
|
|
};
|