diff options
Diffstat (limited to 'node_modules/@jet/environment/routing/routing-components.js')
| -rw-r--r-- | node_modules/@jet/environment/routing/routing-components.js | 295 |
1 files changed, 295 insertions, 0 deletions
diff --git a/node_modules/@jet/environment/routing/routing-components.js b/node_modules/@jet/environment/routing/routing-components.js new file mode 100644 index 0000000..29fa1f9 --- /dev/null +++ b/node_modules/@jet/environment/routing/routing-components.js @@ -0,0 +1,295 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.UrlRouter = exports.UrlRule = void 0; +const optional_1 = require("../types/optional"); +const urls = require("../util/urls"); +// endregion +// region private URLRule helpers. +/** + * Checks whether or not a given pathComponents component contains a parameter. + * @param pathComponent - The pathComponents component to check. + * @returns true if the pathComponents component is surrounded by curly braces; false otherwise. + */ +function isPathComponentParameter(pathComponent) { + return pathComponent.startsWith("{") && pathComponent.endsWith("}"); +} +/** + * Extracts the parameter contained in a pathComponents component. + * @param pathComponent - A pathComponents component surrounded by curly braces. + * @returns The parameter contained in the component. + */ +function getPathComponentParameter(pathComponent) { + return pathComponent.replace("{", "").replace("}", ""); +} +/** + * Creates a mapping from key to pathComponents component index + * for efficiently extracting parameters from a pathComponents. + * @param rulePath - The pathComponents to create a mapping for. + * @returns A map of keys to pathComponents component indexes. + */ +function makePathParameterMapping(rulePath) { + const mapping = {}; + rulePath.forEach((ruleComponent, index) => { + if (isPathComponentParameter(ruleComponent)) { + mapping[ruleComponent] = index; + } + }); + return mapping; +} +/** + * Creates `UrlRouteQuery` objects from substring of url. + * @param parameters - strings of form `<key>[?]=<value>`. + * @returns Array of `UrlRouteQuery` objects. + */ +function parseQuery(parameters) { + const parsedQuery = []; + if ((0, optional_1.isNothing)(parameters)) { + return parsedQuery; + } + for (const param of parameters) { + const parts = param.split("="); + let key = parts[0]; + const optional = key.includes("?"); + key = key.replace("?", ""); + let value = null; + if (parts.length > 1) { + value = decodeURIComponent(parts[1]); + } + parsedQuery.push({ + key, + value, + optional, + }); + } + return parsedQuery; +} +/** + * The `UrlRule` class extracts the pattern format from `UrlRuleDefinition`s, and encapsulates + * the information needed to match against a candidate URL and extract parameters from it. + * + * The terminology here is: + * - rule: A specific url pattern. + * - route: A group of rules that together form a single route, i.e. UrlRule[]. + */ +class UrlRule { + /** + * Construct the route with all required properties. + * @param rule - The rule to match. + */ + constructor(rule) { + this.identifier = rule.identifier; + this.protocol = rule.protocol; + this.hostName = rule.hostName; + if ((0, optional_1.isSome)(rule.path)) { + this.pathComponents = rule.path.split("/").filter((component) => component.length > 0); + this.pathParameterMap = makePathParameterMapping(this.pathComponents); + } + else { + this.pathComponents = undefined; + this.pathParameterMap = undefined; + } + this.pathExtension = rule.pathExtension; + this.query = parseQuery(rule.query); + this.hash = rule.hash; + this.regex = rule.regex; + if ((0, optional_1.isSome)(rule.exclusions)) { + this.exclusions = rule.exclusions.map(function (ex) { + return new UrlRule(ex); + }); + } + else { + this.exclusions = undefined; + } + } + /** + * Checks whether or not the route matches a given URL. + * @param url - The URL to check against. + * @returns true if the route matches `urls`; false otherwise. + * + * @deprecated prefer `match` to have access to regex match groups + */ + matches(url) { + return (0, optional_1.isSome)(this.match(url)); + } + /** + * Extract information from a matching url. + * @param matchingUrl - The url to extract parameters from. + * @returns `Parameters` extracted from `matchingUrl` + * @remarks This function is only valid when `this.matches(matchingUrl) === true`. + */ + extractParameters(matchingUrl) { + var _a; + const parameters = {}; + if ((0, optional_1.isSome)(this.pathComponents) && (0, optional_1.isSome)(this.pathParameterMap)) { + const urlPathComponents = matchingUrl.pathComponents(); + for (const internalKey of Object.keys(this.pathParameterMap)) { + const externalKey = getPathComponentParameter(internalKey); + const index = this.pathParameterMap[internalKey]; + parameters[externalKey] = decodeURIComponent(urlPathComponents[index]); + } + } + if ((0, optional_1.isSome)(this.query)) { + for (const param of this.query) { + const queryParam = (_a = matchingUrl.query) === null || _a === void 0 ? void 0 : _a[param.key]; + if ((0, optional_1.isSome)(queryParam)) { + parameters[param.key] = queryParam; + } + } + } + return parameters; + } + /** + * Checks whether or not the route matches a given URL. + * @param url - The URL to check against. + * @returns an optional `UrlRuleMatchResult` if the route matches `url`. + */ + match(url) { + var _a, _b; + let matchGroups = null; + if ((0, optional_1.isSome)(this.regex)) { + if (this.regex.length === 0) { + // If the rule specifies regex but does not supply patterns, we need to return false. Otherwise, we will + // risk matching against everything. This is because an empty regex with no other rule parameters will + // cause us to fallthrough to the end and match against all URLs. + return null; + } + let didMatchRegex = false; + for (const regexPattern of this.regex) { + const execResult = regexPattern.exec(url.toString()); + if (execResult !== null) { + // If we match against any of regex patterns, then we should proceed. + // If no matches are found, then this rule is not matched. + didMatchRegex = true; + matchGroups = (_a = execResult.groups) !== null && _a !== void 0 ? _a : null; + break; + } + } + if (!didMatchRegex) { + return null; + } + } + if ((0, optional_1.isSome)(this.protocol) && url.protocol !== this.protocol) { + return null; + } + if ((0, optional_1.isSome)(this.hostName) && url.host !== this.hostName) { + return null; + } + if ((0, optional_1.isSome)(this.pathComponents)) { + const rulePathComponents = this.pathComponents; + const urlPathComponents = url.pathComponents(); + if (rulePathComponents.length !== urlPathComponents.length) { + return null; + } + // We're iterating two arrays here, an old style for-loop is appropriate + const length = rulePathComponents.length; + for (let i = 0; i < length; i += 1) { + const ruleComponent = rulePathComponents[i]; + if (isPathComponentParameter(ruleComponent)) { + // component parameters always match + continue; + } + const urlComponent = urlPathComponents[i]; + if (ruleComponent !== urlComponent) { + return null; + } + } + } + if ((0, optional_1.isSome)(this.pathExtension)) { + if (url.pathExtension() !== this.pathExtension) { + return null; + } + } + if ((0, optional_1.isSome)(this.query)) { + for (const param of this.query) { + const value = (_b = url.query) === null || _b === void 0 ? void 0 : _b[param.key]; + if ((0, optional_1.isNothing)(value) && !param.optional) { + return null; + } + if ((0, optional_1.isSome)(param.value) && param.value !== value) { + return null; + } + } + } + if ((0, optional_1.isSome)(this.hash) && url.hash !== this.hash) { + return null; + } + if ((0, optional_1.isSome)(this.exclusions)) { + for (const exclusionRule of this.exclusions) { + if ((0, optional_1.isSome)(exclusionRule.exclusions)) { + throw Error("Matching exclusion rules with further exclusion rules may introduce significant code-complexity and/or reduce the ease with which developers are able to reason about your desired goals. Are there any simpler options?"); + } + if ((0, optional_1.isSome)(exclusionRule.match(url))) { + return null; + } + } + } + const parameters = this.extractParameters(url); + return { + parameters, + matchGroups, + }; + } +} +exports.UrlRule = UrlRule; +/** + * `UrlRouter` manages a set of url rule templates to allow `urls` to serve as keys for different associated objects (like Builders). + * + * @remarks This is replaces old `UrlRouter` as a synchronous way match route URLs to handlers. In contrast to the previous implementation, + * it maps entire objects (containing related async handlers and properties) to urls. + */ +class UrlRouter { + /** + * Constructs an empty URL router object. + */ + constructor() { + this.routeMappings = []; + } + /** + * Register a new route defined by a set of definitions and object on the router. + * @param routeDefinitions - The definitions of rules to register. + * @param object - The object for the rule. + */ + associate(routeDefinitions, object) { + const route = []; + for (const definition of routeDefinitions) { + route.push(new UrlRule(definition)); + } + this.routeMappings.push({ route: route, object: object }); + } + /** + * Resolve given url to associated object, if any exist. Rules will be evaluated + * in the order they are added using the `associate` function. Evaluation will stop + * after any rule matches. + * @param urlOrString - URL or string representation of url to resolve objects for. + * @returns `UrlRouterResult` containing url, extracted parameters, and associated object, or `null` if no match was found. + */ + routedObjectForUrl(urlOrString) { + var _a; + const url = typeof urlOrString === "string" ? new urls.URL(urlOrString) : urlOrString; + for (const mapping of this.routeMappings) { + for (const rule of mapping.route) { + const matchResult = rule.match(url); + if ((0, optional_1.isSome)(matchResult)) { + return { + normalizedUrl: url, + parameters: matchResult.parameters, + object: mapping.object, + matchedRuleIdentifier: (_a = rule.identifier) !== null && _a !== void 0 ? _a : null, + regexMatchGroups: matchResult.matchGroups, + }; + } + } + } + // No match. Still return a result with normalized url. + return { + normalizedUrl: url, + parameters: null, + object: null, + matchedRuleIdentifier: null, + regexMatchGroups: null, + }; + } +} +exports.UrlRouter = UrlRouter; +// endregion +//# sourceMappingURL=routing-components.js.map
\ No newline at end of file |