update
This commit is contained in:
@@ -0,0 +1,181 @@
|
||||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* @fileoverview Main CLI that is run via the eslint command.
|
||||
* @author Nicholas C. Zakas
|
||||
*/
|
||||
|
||||
/* eslint no-console:off -- CLI */
|
||||
|
||||
"use strict";
|
||||
|
||||
const mod = require("node:module");
|
||||
|
||||
// to use V8's code cache to speed up instantiation time
|
||||
mod.enableCompileCache?.();
|
||||
|
||||
// must do this initialization *before* other requires in order to work
|
||||
if (process.argv.includes("--debug")) {
|
||||
require("debug").enable("eslint:*,-eslint:code-path,eslintrc:*");
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Read data from stdin til the end.
|
||||
*
|
||||
* Note: See
|
||||
* - https://github.com/nodejs/node/blob/master/doc/api/process.md#processstdin
|
||||
* - https://github.com/nodejs/node/blob/master/doc/api/process.md#a-note-on-process-io
|
||||
* - https://lists.gnu.org/archive/html/bug-gnu-emacs/2016-01/msg00419.html
|
||||
* - https://github.com/nodejs/node/issues/7439 (historical)
|
||||
*
|
||||
* On Windows using `fs.readFileSync(STDIN_FILE_DESCRIPTOR, "utf8")` seems
|
||||
* to read 4096 bytes before blocking and never drains to read further data.
|
||||
*
|
||||
* The investigation on the Emacs thread indicates:
|
||||
*
|
||||
* > Emacs on MS-Windows uses pipes to communicate with subprocesses; a
|
||||
* > pipe on Windows has a 4K buffer. So as soon as Emacs writes more than
|
||||
* > 4096 bytes to the pipe, the pipe becomes full, and Emacs then waits for
|
||||
* > the subprocess to read its end of the pipe, at which time Emacs will
|
||||
* > write the rest of the stuff.
|
||||
* @returns {Promise<string>} The read text.
|
||||
*/
|
||||
function readStdin() {
|
||||
return new Promise((resolve, reject) => {
|
||||
let content = "";
|
||||
let chunk = "";
|
||||
|
||||
process.stdin
|
||||
.setEncoding("utf8")
|
||||
.on("readable", () => {
|
||||
while ((chunk = process.stdin.read()) !== null) {
|
||||
content += chunk;
|
||||
}
|
||||
})
|
||||
.on("end", () => resolve(content))
|
||||
.on("error", reject);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the error message of a given value.
|
||||
* @param {any} error The value to get.
|
||||
* @returns {string} The error message.
|
||||
*/
|
||||
function getErrorMessage(error) {
|
||||
// Lazy loading because this is used only if an error happened.
|
||||
const util = require("node:util");
|
||||
|
||||
// Foolproof -- third-party module might throw non-object.
|
||||
if (typeof error !== "object" || error === null) {
|
||||
return String(error);
|
||||
}
|
||||
|
||||
// Use templates if `error.messageTemplate` is present.
|
||||
if (typeof error.messageTemplate === "string") {
|
||||
try {
|
||||
const template = require(`../messages/${error.messageTemplate}.js`);
|
||||
|
||||
return template(error.messageData || {});
|
||||
} catch {
|
||||
// Ignore template error then fallback to use `error.stack`.
|
||||
}
|
||||
}
|
||||
|
||||
// Use the stacktrace if it's an error object.
|
||||
if (typeof error.stack === "string") {
|
||||
return error.stack;
|
||||
}
|
||||
|
||||
// Otherwise, dump the object.
|
||||
return util.format("%o", error);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tracks error messages that are shown to the user so we only ever show the
|
||||
* same message once.
|
||||
* @type {Set<string>}
|
||||
*/
|
||||
const displayedErrors = new Set();
|
||||
|
||||
/**
|
||||
* Tracks whether an unexpected error was caught
|
||||
* @type {boolean}
|
||||
*/
|
||||
let hadFatalError = false;
|
||||
|
||||
/**
|
||||
* Catch and report unexpected error.
|
||||
* @param {any} error The thrown error object.
|
||||
* @returns {void}
|
||||
*/
|
||||
function onFatalError(error) {
|
||||
process.exitCode = 2;
|
||||
hadFatalError = true;
|
||||
|
||||
const { version } = require("../package.json");
|
||||
const message = `
|
||||
Oops! Something went wrong! :(
|
||||
|
||||
ESLint: ${version}
|
||||
|
||||
${getErrorMessage(error)}`;
|
||||
|
||||
if (!displayedErrors.has(message)) {
|
||||
console.error(message);
|
||||
displayedErrors.add(message);
|
||||
}
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Execution
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
(async function main() {
|
||||
process.on("uncaughtException", onFatalError);
|
||||
process.on("unhandledRejection", onFatalError);
|
||||
|
||||
// Call the config initializer if `--init` is present.
|
||||
if (process.argv.includes("--init")) {
|
||||
// `eslint --init` has been moved to `@eslint/create-config`
|
||||
console.warn(
|
||||
"You can also run this command directly using 'npm init @eslint/config@latest'.",
|
||||
);
|
||||
|
||||
const spawn = require("cross-spawn");
|
||||
|
||||
spawn.sync("npm", ["init", "@eslint/config@latest"], {
|
||||
encoding: "utf8",
|
||||
stdio: "inherit",
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
// Otherwise, call the CLI.
|
||||
const cli = require("../lib/cli");
|
||||
const exitCode = await cli.execute(
|
||||
process.argv,
|
||||
process.argv.includes("--stdin") ? await readStdin() : null,
|
||||
true,
|
||||
);
|
||||
|
||||
/*
|
||||
* If an uncaught exception or unhandled rejection was detected in the meantime,
|
||||
* keep the fatal exit code 2 that is already assigned to `process.exitCode`.
|
||||
* Without this condition, exit code 2 (unsuccessful execution) could be overwritten with
|
||||
* 1 (successful execution, lint problems found) or even 0 (successful execution, no lint problems found).
|
||||
* This ensures that unexpected errors that seemingly don't affect the success
|
||||
* of the execution will still cause a non-zero exit code, as it's a common
|
||||
* practice and the default behavior of Node.js to exit with non-zero
|
||||
* in case of an uncaught exception or unhandled rejection.
|
||||
*
|
||||
* Otherwise, assign the exit code returned from CLI.
|
||||
*/
|
||||
if (!hadFatalError) {
|
||||
process.exitCode = exitCode;
|
||||
}
|
||||
})().catch(onFatalError);
|
||||
@@ -0,0 +1,364 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.evaluate = evaluate;
|
||||
exports.evaluateTruthy = evaluateTruthy;
|
||||
const VALID_OBJECT_CALLEES = ["Number", "String", "Math"];
|
||||
const VALID_IDENTIFIER_CALLEES = ["isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", null, null];
|
||||
const INVALID_METHODS = ["random"];
|
||||
function isValidObjectCallee(val) {
|
||||
return VALID_OBJECT_CALLEES.includes(val);
|
||||
}
|
||||
function isValidIdentifierCallee(val) {
|
||||
return VALID_IDENTIFIER_CALLEES.includes(val);
|
||||
}
|
||||
function isInvalidMethod(val) {
|
||||
return INVALID_METHODS.includes(val);
|
||||
}
|
||||
function evaluateTruthy() {
|
||||
const res = this.evaluate();
|
||||
if (res.confident) return !!res.value;
|
||||
}
|
||||
function deopt(path, state) {
|
||||
if (!state.confident) return;
|
||||
state.deoptPath = path;
|
||||
state.confident = false;
|
||||
}
|
||||
const Globals = new Map([["undefined", undefined], ["Infinity", Infinity], ["NaN", NaN]]);
|
||||
function evaluateCached(path, state) {
|
||||
const {
|
||||
node
|
||||
} = path;
|
||||
const {
|
||||
seen
|
||||
} = state;
|
||||
if (seen.has(node)) {
|
||||
const existing = seen.get(node);
|
||||
if (existing.resolved) {
|
||||
return existing.value;
|
||||
} else {
|
||||
deopt(path, state);
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
const item = {
|
||||
resolved: false
|
||||
};
|
||||
seen.set(node, item);
|
||||
const val = _evaluate(path, state);
|
||||
if (state.confident) {
|
||||
item.resolved = true;
|
||||
item.value = val;
|
||||
}
|
||||
return val;
|
||||
}
|
||||
}
|
||||
function _evaluate(path, state) {
|
||||
if (!state.confident) return;
|
||||
if (path.isSequenceExpression()) {
|
||||
const exprs = path.get("expressions");
|
||||
return evaluateCached(exprs[exprs.length - 1], state);
|
||||
}
|
||||
if (path.isStringLiteral() || path.isNumericLiteral() || path.isBooleanLiteral()) {
|
||||
return path.node.value;
|
||||
}
|
||||
if (path.isNullLiteral()) {
|
||||
return null;
|
||||
}
|
||||
if (path.isTemplateLiteral()) {
|
||||
return evaluateQuasis(path, path.node.quasis, state);
|
||||
}
|
||||
if (path.isTaggedTemplateExpression() && path.get("tag").isMemberExpression()) {
|
||||
const object = path.get("tag.object");
|
||||
const {
|
||||
node: {
|
||||
name
|
||||
}
|
||||
} = object;
|
||||
const property = path.get("tag.property");
|
||||
if (object.isIdentifier() && name === "String" && !path.scope.getBinding(name) && property.isIdentifier() && property.node.name === "raw") {
|
||||
return evaluateQuasis(path, path.node.quasi.quasis, state, true);
|
||||
}
|
||||
}
|
||||
if (path.isConditionalExpression()) {
|
||||
const testResult = evaluateCached(path.get("test"), state);
|
||||
if (!state.confident) return;
|
||||
if (testResult) {
|
||||
return evaluateCached(path.get("consequent"), state);
|
||||
} else {
|
||||
return evaluateCached(path.get("alternate"), state);
|
||||
}
|
||||
}
|
||||
if (path.isExpressionWrapper()) {
|
||||
return evaluateCached(path.get("expression"), state);
|
||||
}
|
||||
if (path.isMemberExpression() && !path.parentPath.isCallExpression({
|
||||
callee: path.node
|
||||
})) {
|
||||
const property = path.get("property");
|
||||
const object = path.get("object");
|
||||
if (object.isLiteral()) {
|
||||
const value = object.node.value;
|
||||
const type = typeof value;
|
||||
let key = null;
|
||||
if (path.node.computed) {
|
||||
key = evaluateCached(property, state);
|
||||
if (!state.confident) return;
|
||||
} else if (property.isIdentifier()) {
|
||||
key = property.node.name;
|
||||
}
|
||||
if ((type === "number" || type === "string") && key != null && (typeof key === "number" || typeof key === "string")) {
|
||||
return value[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
if (path.isReferencedIdentifier()) {
|
||||
const binding = path.scope.getBinding(path.node.name);
|
||||
if (binding) {
|
||||
if (binding.constantViolations.length > 0 || path.node.start < binding.path.node.end) {
|
||||
deopt(binding.path, state);
|
||||
return;
|
||||
}
|
||||
const bindingPathScope = binding.path.scope;
|
||||
if (binding.kind === "var" && bindingPathScope !== binding.scope) {
|
||||
let hasUnsafeBlock = !bindingPathScope.path.parentPath.isBlockStatement();
|
||||
for (let scope = bindingPathScope.parent; scope; scope = scope.parent) {
|
||||
var _scope$path$parentPat;
|
||||
if (scope === path.scope) {
|
||||
if (hasUnsafeBlock) {
|
||||
deopt(binding.path, state);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if ((_scope$path$parentPat = scope.path.parentPath) != null && _scope$path$parentPat.isBlockStatement()) {
|
||||
hasUnsafeBlock = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (binding.hasValue) {
|
||||
return binding.value;
|
||||
}
|
||||
}
|
||||
const name = path.node.name;
|
||||
if (Globals.has(name)) {
|
||||
if (!binding) {
|
||||
return Globals.get(name);
|
||||
}
|
||||
deopt(binding.path, state);
|
||||
return;
|
||||
}
|
||||
const resolved = path.resolve();
|
||||
if (resolved === path) {
|
||||
deopt(path, state);
|
||||
return;
|
||||
} else {
|
||||
return evaluateCached(resolved, state);
|
||||
}
|
||||
}
|
||||
if (path.isUnaryExpression({
|
||||
prefix: true
|
||||
})) {
|
||||
if (path.node.operator === "void") {
|
||||
return undefined;
|
||||
}
|
||||
const argument = path.get("argument");
|
||||
if (path.node.operator === "typeof" && (argument.isFunction() || argument.isClass())) {
|
||||
return "function";
|
||||
}
|
||||
const arg = evaluateCached(argument, state);
|
||||
if (!state.confident) return;
|
||||
switch (path.node.operator) {
|
||||
case "!":
|
||||
return !arg;
|
||||
case "+":
|
||||
return +arg;
|
||||
case "-":
|
||||
return -arg;
|
||||
case "~":
|
||||
return ~arg;
|
||||
case "typeof":
|
||||
return typeof arg;
|
||||
}
|
||||
}
|
||||
if (path.isArrayExpression()) {
|
||||
const arr = [];
|
||||
const elems = path.get("elements");
|
||||
for (const elem of elems) {
|
||||
const elemValue = elem.evaluate();
|
||||
if (elemValue.confident) {
|
||||
arr.push(elemValue.value);
|
||||
} else {
|
||||
deopt(elemValue.deopt, state);
|
||||
return;
|
||||
}
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
if (path.isObjectExpression()) {
|
||||
const obj = {};
|
||||
const props = path.get("properties");
|
||||
for (const prop of props) {
|
||||
if (prop.isObjectMethod() || prop.isSpreadElement()) {
|
||||
deopt(prop, state);
|
||||
return;
|
||||
}
|
||||
const keyPath = prop.get("key");
|
||||
let key;
|
||||
if (prop.node.computed) {
|
||||
key = keyPath.evaluate();
|
||||
if (!key.confident) {
|
||||
deopt(key.deopt, state);
|
||||
return;
|
||||
}
|
||||
key = key.value;
|
||||
} else if (keyPath.isIdentifier()) {
|
||||
key = keyPath.node.name;
|
||||
} else {
|
||||
key = keyPath.node.value;
|
||||
}
|
||||
const valuePath = prop.get("value");
|
||||
let value = valuePath.evaluate();
|
||||
if (!value.confident) {
|
||||
deopt(value.deopt, state);
|
||||
return;
|
||||
}
|
||||
value = value.value;
|
||||
obj[key] = value;
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
if (path.isLogicalExpression()) {
|
||||
const wasConfident = state.confident;
|
||||
const left = evaluateCached(path.get("left"), state);
|
||||
const leftConfident = state.confident;
|
||||
state.confident = wasConfident;
|
||||
const right = evaluateCached(path.get("right"), state);
|
||||
const rightConfident = state.confident;
|
||||
switch (path.node.operator) {
|
||||
case "||":
|
||||
state.confident = leftConfident && (!!left || rightConfident);
|
||||
if (!state.confident) return;
|
||||
return left || right;
|
||||
case "&&":
|
||||
state.confident = leftConfident && (!left || rightConfident);
|
||||
if (!state.confident) return;
|
||||
return left && right;
|
||||
case "??":
|
||||
state.confident = leftConfident && (left != null || rightConfident);
|
||||
if (!state.confident) return;
|
||||
return left != null ? left : right;
|
||||
}
|
||||
}
|
||||
if (path.isBinaryExpression()) {
|
||||
const left = evaluateCached(path.get("left"), state);
|
||||
if (!state.confident) return;
|
||||
const right = evaluateCached(path.get("right"), state);
|
||||
if (!state.confident) return;
|
||||
switch (path.node.operator) {
|
||||
case "-":
|
||||
return left - right;
|
||||
case "+":
|
||||
return left + right;
|
||||
case "/":
|
||||
return left / right;
|
||||
case "*":
|
||||
return left * right;
|
||||
case "%":
|
||||
return left % right;
|
||||
case "**":
|
||||
return Math.pow(left, right);
|
||||
case "<":
|
||||
return left < right;
|
||||
case ">":
|
||||
return left > right;
|
||||
case "<=":
|
||||
return left <= right;
|
||||
case ">=":
|
||||
return left >= right;
|
||||
case "==":
|
||||
return left == right;
|
||||
case "!=":
|
||||
return left != right;
|
||||
case "===":
|
||||
return left === right;
|
||||
case "!==":
|
||||
return left !== right;
|
||||
case "|":
|
||||
return left | right;
|
||||
case "&":
|
||||
return left & right;
|
||||
case "^":
|
||||
return left ^ right;
|
||||
case "<<":
|
||||
return left << right;
|
||||
case ">>":
|
||||
return left >> right;
|
||||
case ">>>":
|
||||
return left >>> right;
|
||||
}
|
||||
}
|
||||
if (path.isCallExpression()) {
|
||||
const callee = path.get("callee");
|
||||
let context;
|
||||
let func;
|
||||
if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && (isValidObjectCallee(callee.node.name) || isValidIdentifierCallee(callee.node.name))) {
|
||||
func = global[callee.node.name];
|
||||
}
|
||||
if (callee.isMemberExpression()) {
|
||||
const object = callee.get("object");
|
||||
const property = callee.get("property");
|
||||
if (object.isIdentifier() && property.isIdentifier() && isValidObjectCallee(object.node.name) && !isInvalidMethod(property.node.name)) {
|
||||
context = global[object.node.name];
|
||||
const key = property.node.name;
|
||||
if (hasOwnProperty.call(context, key)) {
|
||||
func = context[key];
|
||||
}
|
||||
}
|
||||
if (object.isLiteral() && property.isIdentifier()) {
|
||||
const type = typeof object.node.value;
|
||||
if (type === "string" || type === "number") {
|
||||
context = object.node.value;
|
||||
func = context[property.node.name];
|
||||
}
|
||||
}
|
||||
}
|
||||
if (func) {
|
||||
const args = path.get("arguments").map(arg => evaluateCached(arg, state));
|
||||
if (!state.confident) return;
|
||||
return func.apply(context, args);
|
||||
}
|
||||
}
|
||||
deopt(path, state);
|
||||
}
|
||||
function evaluateQuasis(path, quasis, state, raw = false) {
|
||||
let str = "";
|
||||
let i = 0;
|
||||
const exprs = path.isTemplateLiteral() ? path.get("expressions") : path.get("quasi.expressions");
|
||||
for (const elem of quasis) {
|
||||
if (!state.confident) break;
|
||||
str += raw ? elem.value.raw : elem.value.cooked;
|
||||
const expr = exprs[i++];
|
||||
if (expr) str += String(evaluateCached(expr, state));
|
||||
}
|
||||
if (!state.confident) return;
|
||||
return str;
|
||||
}
|
||||
function evaluate() {
|
||||
const state = {
|
||||
confident: true,
|
||||
deoptPath: null,
|
||||
seen: new Map()
|
||||
};
|
||||
let value = evaluateCached(this, state);
|
||||
if (!state.confident) value = undefined;
|
||||
return {
|
||||
confident: state.confident,
|
||||
deopt: state.deoptPath,
|
||||
value: value
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=evaluation.js.map
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_traverseFast","require","_removeProperties","removePropertiesDeep","tree","opts","traverseFast","removeProperties"],"sources":["../../src/modifications/removePropertiesDeep.ts"],"sourcesContent":["import traverseFast from \"../traverse/traverseFast.ts\";\nimport removeProperties from \"./removeProperties.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function removePropertiesDeep<T extends t.Node>(\n tree: T,\n opts?: { preserveComments: boolean } | null,\n): T {\n traverseFast(tree, removeProperties, opts);\n\n return tree;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AAGe,SAASE,oBAAoBA,CAC1CC,IAAO,EACPC,IAA2C,EACxC;EACH,IAAAC,qBAAY,EAACF,IAAI,EAAEG,yBAAgB,EAAEF,IAAI,CAAC;EAE1C,OAAOD,IAAI;AACb","ignoreList":[]}
|
||||
@@ -0,0 +1,67 @@
|
||||
var test = require('tape')
|
||||
var Expand = require('./')
|
||||
|
||||
test('default expands {} placeholders', function (t) {
|
||||
var expand = Expand()
|
||||
t.equal(typeof expand, 'function', 'is a function')
|
||||
t.equal(expand('{foo}/{bar}', {
|
||||
foo: 'BAR', bar: 'FOO'
|
||||
}), 'BAR/FOO')
|
||||
t.equal(expand('{foo}{foo}{foo}', {
|
||||
foo: 'FOO'
|
||||
}), 'FOOFOOFOO', 'expands one placeholder many times')
|
||||
t.end()
|
||||
})
|
||||
|
||||
test('support for custom separators', function (t) {
|
||||
var expand = Expand({ sep: '[]' })
|
||||
t.equal(expand('[foo]/[bar]', {
|
||||
foo: 'BAR', bar: 'FOO'
|
||||
}), 'BAR/FOO')
|
||||
t.equal(expand('[foo][foo][foo]', {
|
||||
foo: 'FOO'
|
||||
}), 'FOOFOOFOO', 'expands one placeholder many times')
|
||||
t.end()
|
||||
})
|
||||
|
||||
test('support for longer custom separators', function (t) {
|
||||
var expand = Expand({ sep: '[[]]' })
|
||||
t.equal(expand('[[foo]]/[[bar]]', {
|
||||
foo: 'BAR', bar: 'FOO'
|
||||
}), 'BAR/FOO')
|
||||
t.equal(expand('[[foo]][[foo]][[foo]]', {
|
||||
foo: 'FOO'
|
||||
}), 'FOOFOOFOO', 'expands one placeholder many times')
|
||||
t.end()
|
||||
})
|
||||
|
||||
test('whitespace-insensitive', function (t) {
|
||||
var expand = Expand({ sep: '[]' })
|
||||
t.equal(expand('[ foo ]/[ bar ]', {
|
||||
foo: 'BAR', bar: 'FOO'
|
||||
}), 'BAR/FOO')
|
||||
t.equal(expand('[ foo ][ foo ][ foo]', {
|
||||
foo: 'FOO'
|
||||
}), 'FOOFOOFOO', 'expands one placeholder many times')
|
||||
t.end()
|
||||
})
|
||||
|
||||
test('dollar escape', function (t) {
|
||||
var expand = Expand()
|
||||
t.equal(expand('before {foo} after', {
|
||||
foo: '$'
|
||||
}), 'before $ after')
|
||||
t.equal(expand('before {foo} after', {
|
||||
foo: '$&'
|
||||
}), 'before $& after')
|
||||
t.equal(expand('before {foo} after', {
|
||||
foo: '$`'
|
||||
}), 'before $` after')
|
||||
t.equal(expand('before {foo} after', {
|
||||
foo: '$\''
|
||||
}), 'before $\' after')
|
||||
t.equal(expand('before {foo} after', {
|
||||
foo: '$0'
|
||||
}), 'before $0 after')
|
||||
t.end()
|
||||
})
|
||||
@@ -0,0 +1,39 @@
|
||||
{
|
||||
"name": "type-check",
|
||||
"version": "0.4.0",
|
||||
"author": "George Zahariev <z@georgezahariev.com>",
|
||||
"description": "type-check allows you to check the types of JavaScript values at runtime with a Haskell like type syntax.",
|
||||
"homepage": "https://github.com/gkz/type-check",
|
||||
"keywords": [
|
||||
"type",
|
||||
"check",
|
||||
"checking",
|
||||
"library"
|
||||
],
|
||||
"files": [
|
||||
"lib",
|
||||
"README.md",
|
||||
"LICENSE"
|
||||
],
|
||||
"main": "./lib/",
|
||||
"bugs": "https://github.com/gkz/type-check/issues",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
"node": ">= 0.8.0"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/gkz/type-check.git"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "make test"
|
||||
},
|
||||
"dependencies": {
|
||||
"prelude-ls": "^1.2.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"livescript": "^1.6.0",
|
||||
"mocha": "^7.1.1",
|
||||
"browserify": "^16.5.1"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
language: node_js
|
||||
node_js:
|
||||
- lts/*
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"K D E F A B mC"},B:{"1":"0 9 C L M G N O P Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I"},C:{"1":"0 3 4 5 6 7 8 9 RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC oC pC","2":"1 2 nC LC J PB K D E F A B C L M G N O P QB qC rC"},D:{"1":"0 9 iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC","2":"1 2 3 4 5 6 7 8 J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB"},E:{"1":"A B C L M G TC FC GC xC yC zC UC VC HC 0C IC WC XC YC ZC aC 1C JC bC cC dC eC fC 2C KC gC hC iC jC 3C","2":"J PB K D E F sC SC tC uC vC wC"},F:{"1":"0 VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z","2":"1 2 3 4 5 6 7 8 F B C G N O P QB RB SB TB UB 4C 5C 6C 7C FC kC 8C GC"},G:{"1":"GD HD ID JD KD LD MD ND OD PD QD RD SD UC VC HC TD IC WC XC YC ZC aC UD JC bC cC dC eC fC VD KC gC hC iC jC","2":"E SC 9C lC AD BD CD DD ED FD"},H:{"2":"WD"},I:{"1":"I","2":"LC J XD YD ZD aD lC bD cD"},J:{"2":"D A"},K:{"1":"H","2":"A B C FC kC GC"},L:{"1":"I"},M:{"1":"EC"},N:{"2":"A B"},O:{"1":"HC"},P:{"1":"1 2 3 4 5 6 7 8 dD eD fD gD hD TC iD jD kD lD mD IC JC KC nD","2":"J"},Q:{"1":"oD"},R:{"1":"pD"},S:{"1":"qD rD"}},B:6,C:"Arrow functions",D:true};
|
||||
@@ -0,0 +1,187 @@
|
||||
import { BaseRouteApi, notFound, BaseRoute, BaseRootRoute } from "@tanstack/router-core";
|
||||
import { useLoaderData } from "./useLoaderData.js";
|
||||
import { useLoaderDeps } from "./useLoaderDeps.js";
|
||||
import { useParams } from "./useParams.js";
|
||||
import { useSearch } from "./useSearch.js";
|
||||
import { useNavigate } from "./useNavigate.js";
|
||||
import { useMatch } from "./useMatch.js";
|
||||
import { useRouter } from "./useRouter.js";
|
||||
function getRouteApi(id) {
|
||||
return new RouteApi({ id });
|
||||
}
|
||||
class RouteApi extends BaseRouteApi {
|
||||
/**
|
||||
* @deprecated Use the `getRouteApi` function instead.
|
||||
*/
|
||||
constructor({ id }) {
|
||||
super({ id });
|
||||
this.useMatch = (opts) => {
|
||||
return useMatch({
|
||||
select: opts == null ? void 0 : opts.select,
|
||||
from: this.id,
|
||||
structuralSharing: opts == null ? void 0 : opts.structuralSharing
|
||||
});
|
||||
};
|
||||
this.useRouteContext = (opts) => {
|
||||
return useMatch({
|
||||
from: this.id,
|
||||
select: (d) => (opts == null ? void 0 : opts.select) ? opts.select(d.context) : d.context
|
||||
});
|
||||
};
|
||||
this.useSearch = (opts) => {
|
||||
return useSearch({
|
||||
select: opts == null ? void 0 : opts.select,
|
||||
structuralSharing: opts == null ? void 0 : opts.structuralSharing,
|
||||
from: this.id
|
||||
});
|
||||
};
|
||||
this.useParams = (opts) => {
|
||||
return useParams({
|
||||
select: opts == null ? void 0 : opts.select,
|
||||
structuralSharing: opts == null ? void 0 : opts.structuralSharing,
|
||||
from: this.id
|
||||
});
|
||||
};
|
||||
this.useLoaderDeps = (opts) => {
|
||||
return useLoaderDeps({ ...opts, from: this.id, strict: false });
|
||||
};
|
||||
this.useLoaderData = (opts) => {
|
||||
return useLoaderData({ ...opts, from: this.id, strict: false });
|
||||
};
|
||||
this.useNavigate = () => {
|
||||
const router = useRouter();
|
||||
return useNavigate({ from: router.routesById[this.id].fullPath });
|
||||
};
|
||||
this.notFound = (opts) => {
|
||||
return notFound({ routeId: this.id, ...opts });
|
||||
};
|
||||
}
|
||||
}
|
||||
class Route extends BaseRoute {
|
||||
/**
|
||||
* @deprecated Use the `createRoute` function instead.
|
||||
*/
|
||||
constructor(options) {
|
||||
super(options);
|
||||
this.useMatch = (opts) => {
|
||||
return useMatch({
|
||||
select: opts == null ? void 0 : opts.select,
|
||||
from: this.id,
|
||||
structuralSharing: opts == null ? void 0 : opts.structuralSharing
|
||||
});
|
||||
};
|
||||
this.useRouteContext = (opts) => {
|
||||
return useMatch({
|
||||
...opts,
|
||||
from: this.id,
|
||||
select: (d) => (opts == null ? void 0 : opts.select) ? opts.select(d.context) : d.context
|
||||
});
|
||||
};
|
||||
this.useSearch = (opts) => {
|
||||
return useSearch({
|
||||
select: opts == null ? void 0 : opts.select,
|
||||
structuralSharing: opts == null ? void 0 : opts.structuralSharing,
|
||||
from: this.id
|
||||
});
|
||||
};
|
||||
this.useParams = (opts) => {
|
||||
return useParams({
|
||||
select: opts == null ? void 0 : opts.select,
|
||||
structuralSharing: opts == null ? void 0 : opts.structuralSharing,
|
||||
from: this.id
|
||||
});
|
||||
};
|
||||
this.useLoaderDeps = (opts) => {
|
||||
return useLoaderDeps({ ...opts, from: this.id });
|
||||
};
|
||||
this.useLoaderData = (opts) => {
|
||||
return useLoaderData({ ...opts, from: this.id });
|
||||
};
|
||||
this.useNavigate = () => {
|
||||
return useNavigate({ from: this.fullPath });
|
||||
};
|
||||
this.$$typeof = Symbol.for("react.memo");
|
||||
}
|
||||
}
|
||||
function createRoute(options) {
|
||||
return new Route(options);
|
||||
}
|
||||
function createRootRouteWithContext() {
|
||||
return (options) => {
|
||||
return createRootRoute(options);
|
||||
};
|
||||
}
|
||||
const rootRouteWithContext = createRootRouteWithContext;
|
||||
class RootRoute extends BaseRootRoute {
|
||||
/**
|
||||
* @deprecated `RootRoute` is now an internal implementation detail. Use `createRootRoute()` instead.
|
||||
*/
|
||||
constructor(options) {
|
||||
super(options);
|
||||
this.useMatch = (opts) => {
|
||||
return useMatch({
|
||||
select: opts == null ? void 0 : opts.select,
|
||||
from: this.id,
|
||||
structuralSharing: opts == null ? void 0 : opts.structuralSharing
|
||||
});
|
||||
};
|
||||
this.useRouteContext = (opts) => {
|
||||
return useMatch({
|
||||
...opts,
|
||||
from: this.id,
|
||||
select: (d) => (opts == null ? void 0 : opts.select) ? opts.select(d.context) : d.context
|
||||
});
|
||||
};
|
||||
this.useSearch = (opts) => {
|
||||
return useSearch({
|
||||
select: opts == null ? void 0 : opts.select,
|
||||
structuralSharing: opts == null ? void 0 : opts.structuralSharing,
|
||||
from: this.id
|
||||
});
|
||||
};
|
||||
this.useParams = (opts) => {
|
||||
return useParams({
|
||||
select: opts == null ? void 0 : opts.select,
|
||||
structuralSharing: opts == null ? void 0 : opts.structuralSharing,
|
||||
from: this.id
|
||||
});
|
||||
};
|
||||
this.useLoaderDeps = (opts) => {
|
||||
return useLoaderDeps({ ...opts, from: this.id });
|
||||
};
|
||||
this.useLoaderData = (opts) => {
|
||||
return useLoaderData({ ...opts, from: this.id });
|
||||
};
|
||||
this.useNavigate = () => {
|
||||
return useNavigate({ from: this.fullPath });
|
||||
};
|
||||
this.$$typeof = Symbol.for("react.memo");
|
||||
}
|
||||
}
|
||||
function createRootRoute(options) {
|
||||
return new RootRoute(options);
|
||||
}
|
||||
function createRouteMask(opts) {
|
||||
return opts;
|
||||
}
|
||||
class NotFoundRoute extends Route {
|
||||
constructor(options) {
|
||||
super({
|
||||
...options,
|
||||
id: "404"
|
||||
});
|
||||
}
|
||||
}
|
||||
export {
|
||||
NotFoundRoute,
|
||||
RootRoute,
|
||||
Route,
|
||||
RouteApi,
|
||||
createRootRoute,
|
||||
createRootRouteWithContext,
|
||||
createRoute,
|
||||
createRouteMask,
|
||||
getRouteApi,
|
||||
rootRouteWithContext
|
||||
};
|
||||
//# sourceMappingURL=route.js.map
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"K D E F A B mC"},B:{"1":"0 9 d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I","2":"C L M G N O P Q H R S T U V W X Y Z a b c"},C:{"1":"LB MB NB OB I PC EC QC RC oC pC","2":"0 1 2 3 4 5 6 7 8 9 nC LC J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB qC rC"},D:{"1":"0 9 d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC","2":"1 2 3 4 5 6 7 8 J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R S T U V W X Y Z a b c"},E:{"1":"3C","2":"J PB K D E F A B C L M G sC SC tC uC vC wC TC FC GC xC yC zC UC VC HC 0C IC WC XC YC","132":"ZC aC 1C JC bC cC dC eC fC 2C KC gC hC iC jC"},F:{"1":"0 H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z","2":"1 2 3 4 5 6 7 8 F B C G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q 4C 5C 6C 7C FC kC 8C GC"},G:{"2":"E SC 9C lC AD BD CD DD ED FD GD HD ID JD KD LD MD ND OD PD QD RD SD UC VC HC TD IC WC XC YC","132":"ZC aC UD JC bC cC dC eC fC VD KC gC hC iC jC"},H:{"2":"WD"},I:{"1":"I","2":"LC J XD YD ZD aD lC bD cD"},J:{"2":"D A"},K:{"1":"H","2":"A B C FC kC GC"},L:{"1":"I"},M:{"2":"EC"},N:{"2":"A B"},O:{"1":"HC"},P:{"1":"1 2 3 4 5 6 7 8 JC KC nD","2":"J dD eD fD gD hD TC iD jD kD lD mD IC"},Q:{"2":"oD"},R:{"1":"pD"},S:{"2":"qD rD"}},B:5,C:"WebCodecs API",D:true};
|
||||
@@ -0,0 +1,142 @@
|
||||
/**
|
||||
* @fileoverview Rule to forbid control characters from regular expressions.
|
||||
* @author Nicholas C. Zakas
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator;
|
||||
const collector = new (class {
|
||||
constructor() {
|
||||
this._source = "";
|
||||
this._controlChars = [];
|
||||
this._validator = new RegExpValidator(this);
|
||||
}
|
||||
|
||||
onPatternEnter() {
|
||||
/*
|
||||
* `RegExpValidator` may parse the pattern twice in one `validatePattern`.
|
||||
* So `this._controlChars` should be cleared here as well.
|
||||
*
|
||||
* For example, the `/(?<a>\x1f)/` regex will parse the pattern twice.
|
||||
* This is based on the content described in Annex B.
|
||||
* If the regex contains a `GroupName` and the `u` flag is not used, `ParseText` will be called twice.
|
||||
* See https://tc39.es/ecma262/2023/multipage/additional-ecmascript-features-for-web-browsers.html#sec-parsepattern-annexb
|
||||
*/
|
||||
this._controlChars = [];
|
||||
}
|
||||
|
||||
onCharacter(start, end, cp) {
|
||||
if (
|
||||
cp >= 0x00 &&
|
||||
cp <= 0x1f &&
|
||||
(this._source.codePointAt(start) === cp ||
|
||||
this._source.slice(start, end).startsWith("\\x") ||
|
||||
this._source.slice(start, end).startsWith("\\u"))
|
||||
) {
|
||||
this._controlChars.push(`\\x${`0${cp.toString(16)}`.slice(-2)}`);
|
||||
}
|
||||
}
|
||||
|
||||
collectControlChars(regexpStr, flags) {
|
||||
const uFlag = typeof flags === "string" && flags.includes("u");
|
||||
const vFlag = typeof flags === "string" && flags.includes("v");
|
||||
|
||||
this._controlChars = [];
|
||||
this._source = regexpStr;
|
||||
|
||||
try {
|
||||
this._validator.validatePattern(regexpStr, void 0, void 0, {
|
||||
unicode: uFlag,
|
||||
unicodeSets: vFlag,
|
||||
}); // Call onCharacter hook
|
||||
} catch {
|
||||
// Ignore syntax errors in RegExp.
|
||||
}
|
||||
return this._controlChars;
|
||||
}
|
||||
})();
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "problem",
|
||||
|
||||
docs: {
|
||||
description: "Disallow control characters in regular expressions",
|
||||
recommended: true,
|
||||
url: "https://eslint.org/docs/latest/rules/no-control-regex",
|
||||
},
|
||||
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
unexpected:
|
||||
"Unexpected control character(s) in regular expression: {{controlChars}}.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
/**
|
||||
* Get the regex expression
|
||||
* @param {ASTNode} node `Literal` node to evaluate
|
||||
* @returns {{ pattern: string, flags: string | null } | null} Regex if found (the given node is either a regex literal
|
||||
* or a string literal that is the pattern argument of a RegExp constructor call). Otherwise `null`. If flags cannot be determined,
|
||||
* the `flags` property will be `null`.
|
||||
* @private
|
||||
*/
|
||||
function getRegExp(node) {
|
||||
if (node.regex) {
|
||||
return node.regex;
|
||||
}
|
||||
if (
|
||||
typeof node.value === "string" &&
|
||||
(node.parent.type === "NewExpression" ||
|
||||
node.parent.type === "CallExpression") &&
|
||||
node.parent.callee.type === "Identifier" &&
|
||||
node.parent.callee.name === "RegExp" &&
|
||||
node.parent.arguments[0] === node
|
||||
) {
|
||||
const pattern = node.value;
|
||||
const flags =
|
||||
node.parent.arguments.length > 1 &&
|
||||
node.parent.arguments[1].type === "Literal" &&
|
||||
typeof node.parent.arguments[1].value === "string"
|
||||
? node.parent.arguments[1].value
|
||||
: null;
|
||||
|
||||
return { pattern, flags };
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
return {
|
||||
Literal(node) {
|
||||
const regExp = getRegExp(node);
|
||||
|
||||
if (regExp) {
|
||||
const { pattern, flags } = regExp;
|
||||
const controlCharacters = collector.collectControlChars(
|
||||
pattern,
|
||||
flags,
|
||||
);
|
||||
|
||||
if (controlCharacters.length > 0) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unexpected",
|
||||
data: {
|
||||
controlChars: controlCharacters.join(", "),
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
Binary file not shown.
@@ -0,0 +1 @@
|
||||
module.exports={C:{"73":0.00527,"109":0.00527,"113":0.00527,"115":0.22674,"128":0.00527,"129":0.00527,"132":0.03691,"134":0.00527,"135":0.55894,"136":1.20224,_:"2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 110 111 112 114 116 117 118 119 120 121 122 123 124 125 126 127 130 131 133 137 138 139 140 3.5 3.6"},D:{"42":0.00527,"43":0.00527,"45":0.00527,"48":0.00527,"52":0.00527,"57":0.00527,"59":0.00527,"76":0.08964,"79":0.01582,"87":0.03691,"92":0.00527,"93":0.06855,"103":0.1371,"108":0.00527,"109":1.00187,"112":0.00527,"116":0.0791,"122":0.06855,"123":0.01055,"126":0.01055,"127":0.03164,"128":0.22147,"129":0.00527,"130":0.02109,"131":3.56982,"132":0.34802,"133":8.82173,"134":17.33235,_:"4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 44 46 47 49 50 51 53 54 55 56 58 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 77 78 80 81 83 84 85 86 88 89 90 91 94 95 96 97 98 99 100 101 102 104 105 106 107 110 111 113 114 115 117 118 119 120 121 124 125 135 136 137 138"},F:{"95":0.00527,"102":0.00527,"116":0.30583,"117":0.54312,_:"9 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 60 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 96 97 98 99 100 101 103 104 105 106 107 108 109 110 111 112 113 114 115 9.5-9.6 10.0-10.1 10.5 10.6 11.1 11.5 11.6 12.1"},B:{"87":0.04218,"109":0.03691,"113":0.00527,"131":0.01582,"132":0.03164,"133":3.73328,"134":7.67749,_:"12 13 14 15 16 17 18 79 80 81 83 84 85 86 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 110 111 112 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130"},E:{"14":0.08964,_:"0 4 5 6 7 8 9 10 11 12 13 15 3.1 3.2 5.1 6.1 7.1 9.1 10.1 11.1 12.1 15.1 15.2-15.3 15.4 18.4","13.1":0.00527,"14.1":0.01582,"15.5":0.00527,"15.6":0.16874,"16.0":0.02637,"16.1":0.00527,"16.2":0.00527,"16.3":0.00527,"16.4":0.03691,"16.5":0.01055,"16.6":0.22147,"17.0":0.00527,"17.1":0.08964,"17.2":0.03164,"17.3":0.00527,"17.4":0.05273,"17.5":0.06855,"17.6":0.12128,"18.0":0.01055,"18.1":0.08437,"18.2":0.03691,"18.3":1.60299},G:{"8":0,"3.2":0,"4.0-4.1":0,"4.2-4.3":0.00173,"5.0-5.1":0,"6.0-6.1":0.0052,"7.0-7.1":0.00347,"8.1-8.4":0,"9.0-9.2":0.0026,"9.3":0.01213,"10.0-10.2":0.00087,"10.3":0.01993,"11.0-11.2":0.09184,"11.3-11.4":0.00607,"12.0-12.1":0.00347,"12.2-12.5":0.08578,"13.0-13.1":0.00173,"13.2":0.0026,"13.3":0.00347,"13.4-13.7":0.01213,"14.0-14.4":0.03033,"14.5-14.8":0.03639,"15.0-15.1":0.01993,"15.2-15.3":0.01993,"15.4":0.02426,"15.5":0.02773,"15.6-15.8":0.34138,"16.0":0.04852,"16.1":0.09964,"16.2":0.05199,"16.3":0.09011,"16.4":0.01993,"16.5":0.03726,"16.6-16.7":0.40464,"17.0":0.02426,"17.1":0.04332,"17.2":0.03293,"17.3":0.04592,"17.4":0.09184,"17.5":0.20448,"17.6-17.7":0.59352,"18.0":0.16636,"18.1":0.54414,"18.2":0.24348,"18.3":5.08871,"18.4":0.07538},P:{"4":0.01138,"22":0.27306,"23":0.02275,"24":0.01138,"25":0.05689,"26":0.11377,"27":4.45994,_:"20 21 5.0-5.4 6.2-6.4 7.2-7.4 8.2 9.2 10.1 11.1-11.2 12.0 13.0 14.0 15.0 16.0 17.0 18.0 19.0"},I:{"0":0.28774,"3":0,"4":0,"2.1":0,"2.2":0,"2.3":0,"4.1":0,"4.2-4.3":0.00009,"4.4":0,"4.4.3-4.4.4":0.00032},K:{"0":0.15599,_:"10 11 12 11.1 11.5 12.1"},A:{_:"6 7 8 9 10 11 5.5"},S:{_:"2.5 3.0-3.1"},J:{_:"7 10"},N:{_:"10 11"},R:{_:"0"},M:{"0":2.47222},Q:{_:"14.9"},O:{_:"0"},H:{"0":0},L:{"0":31.84071}};
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,11 @@
|
||||
import { useMatch } from "./useMatch.js";
|
||||
function useRouteContext(opts) {
|
||||
return useMatch({
|
||||
...opts,
|
||||
select: (match) => opts.select ? opts.select(match.context) : match.context
|
||||
});
|
||||
}
|
||||
export {
|
||||
useRouteContext
|
||||
};
|
||||
//# sourceMappingURL=useRouteContext.js.map
|
||||
@@ -0,0 +1,423 @@
|
||||
import { LazyRoute } from './fileRoute.js';
|
||||
import { NotFoundError } from './not-found.js';
|
||||
import { NavigateOptions, ParsePathParams } from './link.js';
|
||||
import { ParsedLocation } from './location.js';
|
||||
import { AnyRouteMatch, MakeRouteMatchFromRoute, MakeRouteMatchUnion, RouteMatch } from './Matches.js';
|
||||
import { RootRouteId } from './root.js';
|
||||
import { ParseRoute, RouteById, RoutePaths } from './routeInfo.js';
|
||||
import { AnyRouter, RegisteredRouter } from './router.js';
|
||||
import { BuildLocationFn, NavigateFn } from './RouterProvider.js';
|
||||
import { Assign, Constrain, Expand, IntersectAssign, NoInfer } from './utils.js';
|
||||
import { AnySchema, AnyStandardSchemaValidator, AnyValidator, AnyValidatorAdapter, AnyValidatorObj, DefaultValidator, ResolveSearchValidatorInput, ResolveValidatorOutput, StandardSchemaValidator, ValidatorAdapter, ValidatorFn, ValidatorObj } from './validators.js';
|
||||
export type AnyPathParams = {};
|
||||
export type SearchSchemaInput = {
|
||||
__TSearchSchemaInput__: 'TSearchSchemaInput';
|
||||
};
|
||||
export type AnyContext = {};
|
||||
export interface RouteContext {
|
||||
}
|
||||
export type PreloadableObj = {
|
||||
preload?: () => Promise<void>;
|
||||
};
|
||||
export type RoutePathOptions<TCustomId, TPath> = {
|
||||
path: TPath;
|
||||
} | {
|
||||
id: TCustomId;
|
||||
};
|
||||
export interface StaticDataRouteOption {
|
||||
}
|
||||
export type RoutePathOptionsIntersection<TCustomId, TPath> = {
|
||||
path: TPath;
|
||||
id: TCustomId;
|
||||
};
|
||||
export type SearchFilter<TInput, TResult = TInput> = (prev: TInput) => TResult;
|
||||
export type SearchMiddlewareContext<TSearchSchema> = {
|
||||
search: TSearchSchema;
|
||||
next: (newSearch: TSearchSchema) => TSearchSchema;
|
||||
};
|
||||
export type SearchMiddleware<TSearchSchema> = (ctx: SearchMiddlewareContext<TSearchSchema>) => TSearchSchema;
|
||||
export type ResolveId<TParentRoute, TCustomId extends string, TPath extends string> = TParentRoute extends {
|
||||
id: infer TParentId extends string;
|
||||
} ? RoutePrefix<TParentId, string extends TCustomId ? TPath : TCustomId> : RootRouteId;
|
||||
export type InferFullSearchSchema<TRoute> = TRoute extends {
|
||||
types: {
|
||||
fullSearchSchema: infer TFullSearchSchema;
|
||||
};
|
||||
} ? TFullSearchSchema : {};
|
||||
export type InferFullSearchSchemaInput<TRoute> = TRoute extends {
|
||||
types: {
|
||||
fullSearchSchemaInput: infer TFullSearchSchemaInput;
|
||||
};
|
||||
} ? TFullSearchSchemaInput : {};
|
||||
export type InferAllParams<TRoute> = TRoute extends {
|
||||
types: {
|
||||
allParams: infer TAllParams;
|
||||
};
|
||||
} ? TAllParams : {};
|
||||
export type InferAllContext<TRoute> = unknown extends TRoute ? TRoute : TRoute extends {
|
||||
types: {
|
||||
allContext: infer TAllContext;
|
||||
};
|
||||
} ? TAllContext : {};
|
||||
export type ResolveSearchSchemaFnInput<TSearchValidator> = TSearchValidator extends (input: infer TSearchSchemaInput) => any ? TSearchSchemaInput extends SearchSchemaInput ? Omit<TSearchSchemaInput, keyof SearchSchemaInput> : ResolveSearchSchemaFn<TSearchValidator> : AnySchema;
|
||||
export type ResolveSearchSchemaInput<TSearchValidator> = TSearchValidator extends AnyStandardSchemaValidator ? NonNullable<TSearchValidator['~standard']['types']>['input'] : TSearchValidator extends AnyValidatorAdapter ? TSearchValidator['types']['input'] : TSearchValidator extends AnyValidatorObj ? ResolveSearchSchemaFnInput<TSearchValidator['parse']> : ResolveSearchSchemaFnInput<TSearchValidator>;
|
||||
export type ResolveSearchSchemaFn<TSearchValidator> = TSearchValidator extends (...args: any) => infer TSearchSchema ? TSearchSchema : AnySchema;
|
||||
export type ResolveSearchSchema<TSearchValidator> = unknown extends TSearchValidator ? TSearchValidator : TSearchValidator extends AnyStandardSchemaValidator ? NonNullable<TSearchValidator['~standard']['types']>['output'] : TSearchValidator extends AnyValidatorAdapter ? TSearchValidator['types']['output'] : TSearchValidator extends AnyValidatorObj ? ResolveSearchSchemaFn<TSearchValidator['parse']> : ResolveSearchSchemaFn<TSearchValidator>;
|
||||
export type ParseSplatParams<TPath extends string> = TPath & `${string}$` extends never ? TPath & `${string}$/${string}` extends never ? never : '_splat' : '_splat';
|
||||
export interface SplatParams {
|
||||
_splat?: string;
|
||||
}
|
||||
export type ResolveParams<TPath extends string> = ParseSplatParams<TPath> extends never ? Record<ParsePathParams<TPath>, string> : Record<ParsePathParams<TPath>, string> & SplatParams;
|
||||
export type ParseParamsFn<in out TPath extends string, in out TParams> = (rawParams: ResolveParams<TPath>) => TParams extends Record<ParsePathParams<TPath>, any> ? TParams : Record<ParsePathParams<TPath>, any>;
|
||||
export type StringifyParamsFn<in out TPath extends string, in out TParams> = (params: TParams) => ResolveParams<TPath>;
|
||||
export type ParamsOptions<in out TPath extends string, in out TParams> = {
|
||||
params?: {
|
||||
parse?: ParseParamsFn<TPath, TParams>;
|
||||
stringify?: StringifyParamsFn<TPath, TParams>;
|
||||
};
|
||||
/**
|
||||
@deprecated Use params.parse instead
|
||||
*/
|
||||
parseParams?: ParseParamsFn<TPath, TParams>;
|
||||
/**
|
||||
@deprecated Use params.stringify instead
|
||||
*/
|
||||
stringifyParams?: StringifyParamsFn<TPath, TParams>;
|
||||
};
|
||||
interface RequiredStaticDataRouteOption {
|
||||
staticData: StaticDataRouteOption;
|
||||
}
|
||||
interface OptionalStaticDataRouteOption {
|
||||
staticData?: StaticDataRouteOption;
|
||||
}
|
||||
export type UpdatableStaticRouteOption = {} extends StaticDataRouteOption ? OptionalStaticDataRouteOption : RequiredStaticDataRouteOption;
|
||||
export type MetaDescriptor = {
|
||||
charSet: 'utf-8';
|
||||
} | {
|
||||
title: string;
|
||||
} | {
|
||||
name: string;
|
||||
content: string;
|
||||
} | {
|
||||
property: string;
|
||||
content: string;
|
||||
} | {
|
||||
httpEquiv: string;
|
||||
content: string;
|
||||
} | {
|
||||
'script:ld+json': LdJsonObject;
|
||||
} | {
|
||||
tagName: 'meta' | 'link';
|
||||
[name: string]: string;
|
||||
} | Record<string, unknown>;
|
||||
type LdJsonObject = {
|
||||
[Key in string]: LdJsonValue;
|
||||
} & {
|
||||
[Key in string]?: LdJsonValue | undefined;
|
||||
};
|
||||
type LdJsonArray = Array<LdJsonValue> | ReadonlyArray<LdJsonValue>;
|
||||
type LdJsonPrimitive = string | number | boolean | null;
|
||||
type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
|
||||
export type RouteLinkEntry = {};
|
||||
export type SearchValidator<TInput, TOutput> = ValidatorObj<TInput, TOutput> | ValidatorFn<TInput, TOutput> | ValidatorAdapter<TInput, TOutput> | StandardSchemaValidator<TInput, TOutput> | undefined;
|
||||
export type AnySearchValidator = SearchValidator<any, any>;
|
||||
export type DefaultSearchValidator = SearchValidator<Record<string, unknown>, AnySchema>;
|
||||
export type RoutePrefix<TPrefix extends string, TPath extends string> = string extends TPath ? RootRouteId : TPath extends string ? TPrefix extends RootRouteId ? TPath extends '/' ? '/' : `/${TrimPath<TPath>}` : `${TPrefix}/${TPath}` extends '/' ? '/' : `/${TrimPathLeft<`${TrimPathRight<TPrefix>}/${TrimPath<TPath>}`>}` : never;
|
||||
export type TrimPath<T extends string> = '' extends T ? '' : TrimPathRight<TrimPathLeft<T>>;
|
||||
export type TrimPathLeft<T extends string> = T extends `${RootRouteId}/${infer U}` ? TrimPathLeft<U> : T extends `/${infer U}` ? TrimPathLeft<U> : T;
|
||||
export type TrimPathRight<T extends string> = T extends '/' ? '/' : T extends `${infer U}/` ? TrimPathRight<U> : T;
|
||||
export type LooseReturnType<T> = T extends (...args: Array<any>) => infer TReturn ? TReturn : never;
|
||||
export type LooseAsyncReturnType<T> = T extends (...args: Array<any>) => infer TReturn ? TReturn extends Promise<infer TReturn> ? TReturn : TReturn : never;
|
||||
export type ContextReturnType<TContextFn> = unknown extends TContextFn ? TContextFn : LooseReturnType<TContextFn> extends never ? AnyContext : LooseReturnType<TContextFn>;
|
||||
export type ContextAsyncReturnType<TContextFn> = unknown extends TContextFn ? TContextFn : LooseAsyncReturnType<TContextFn> extends never ? AnyContext : LooseAsyncReturnType<TContextFn>;
|
||||
export type ResolveRouteContext<TRouteContextFn, TBeforeLoadFn> = Assign<ContextReturnType<TRouteContextFn>, ContextAsyncReturnType<TBeforeLoadFn>>;
|
||||
export type ResolveLoaderData<TLoaderFn> = unknown extends TLoaderFn ? TLoaderFn : LooseAsyncReturnType<TLoaderFn> extends never ? undefined : LooseAsyncReturnType<TLoaderFn>;
|
||||
export type ResolveFullSearchSchema<TParentRoute extends AnyRoute, TSearchValidator> = unknown extends TParentRoute ? ResolveValidatorOutput<TSearchValidator> : IntersectAssign<InferFullSearchSchema<TParentRoute>, ResolveValidatorOutput<TSearchValidator>>;
|
||||
export type ResolveFullSearchSchemaInput<TParentRoute extends AnyRoute, TSearchValidator> = IntersectAssign<InferFullSearchSchemaInput<TParentRoute>, ResolveSearchValidatorInput<TSearchValidator>>;
|
||||
export type ResolveAllParamsFromParent<TParentRoute extends AnyRoute, TParams> = Assign<InferAllParams<TParentRoute>, TParams>;
|
||||
export type RouteContextParameter<TParentRoute extends AnyRoute, TRouterContext> = unknown extends TParentRoute ? TRouterContext : Assign<TRouterContext, InferAllContext<TParentRoute>>;
|
||||
export type BeforeLoadContextParameter<TParentRoute extends AnyRoute, TRouterContext, TRouteContextFn> = Assign<RouteContextParameter<TParentRoute, TRouterContext>, ContextReturnType<TRouteContextFn>>;
|
||||
export type ResolveAllContext<TParentRoute extends AnyRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn> = Assign<BeforeLoadContextParameter<TParentRoute, TRouterContext, TRouteContextFn>, ContextAsyncReturnType<TBeforeLoadFn>>;
|
||||
export interface FullSearchSchemaOption<in out TParentRoute extends AnyRoute, in out TSearchValidator> {
|
||||
search: Expand<ResolveFullSearchSchema<TParentRoute, TSearchValidator>>;
|
||||
}
|
||||
export interface RemountDepsOptions<in out TRouteId, in out TFullSearchSchema, in out TAllParams, in out TLoaderDeps> {
|
||||
routeId: TRouteId;
|
||||
search: TFullSearchSchema;
|
||||
params: TAllParams;
|
||||
loaderDeps: TLoaderDeps;
|
||||
}
|
||||
export type MakeRemountDepsOptionsUnion<TRouteTree extends AnyRoute = RegisteredRouter['routeTree']> = ParseRoute<TRouteTree> extends infer TRoute extends AnyRoute ? TRoute extends any ? RemountDepsOptions<TRoute['id'], TRoute['types']['fullSearchSchema'], TRoute['types']['allParams'], TRoute['types']['loaderDeps']> : never : never;
|
||||
export interface RouteTypes<in out TParentRoute extends AnyRoute, in out TPath extends string, in out TFullPath extends string, in out TCustomId extends string, in out TId extends string, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn, in out TLoaderDeps, in out TLoaderFn, in out TChildren, in out TFileRouteTypes> {
|
||||
parentRoute: TParentRoute;
|
||||
path: TPath;
|
||||
to: TrimPathRight<TFullPath>;
|
||||
fullPath: TFullPath;
|
||||
customId: TCustomId;
|
||||
id: TId;
|
||||
searchSchema: ResolveValidatorOutput<TSearchValidator>;
|
||||
searchSchemaInput: ResolveSearchValidatorInput<TSearchValidator>;
|
||||
searchValidator: TSearchValidator;
|
||||
fullSearchSchema: ResolveFullSearchSchema<TParentRoute, TSearchValidator>;
|
||||
fullSearchSchemaInput: ResolveFullSearchSchemaInput<TParentRoute, TSearchValidator>;
|
||||
params: TParams;
|
||||
allParams: ResolveAllParamsFromParent<TParentRoute, TParams>;
|
||||
routerContext: TRouterContext;
|
||||
routeContext: ResolveRouteContext<TRouteContextFn, TBeforeLoadFn>;
|
||||
routeContextFn: TRouteContextFn;
|
||||
beforeLoadFn: TBeforeLoadFn;
|
||||
allContext: ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>;
|
||||
children: TChildren;
|
||||
loaderData: ResolveLoaderData<TLoaderFn>;
|
||||
loaderDeps: TLoaderDeps;
|
||||
fileRouteTypes: TFileRouteTypes;
|
||||
}
|
||||
export type ResolveFullPath<TParentRoute extends AnyRoute, TPath extends string, TPrefixed = RoutePrefix<TParentRoute['fullPath'], TPath>> = TPrefixed extends RootRouteId ? '/' : TPrefixed;
|
||||
export interface RouteExtensions<TId, TFullPath> {
|
||||
}
|
||||
export type RouteLazyFn<TRoute extends AnyRoute> = (lazyFn: () => Promise<LazyRoute>) => TRoute;
|
||||
export type RouteAddChildrenFn<in out TParentRoute extends AnyRoute, in out TPath extends string, in out TFullPath extends string, in out TCustomId extends string, in out TId extends string, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn, in out TLoaderDeps extends Record<string, any>, in out TLoaderFn, in out TFileRouteTypes> = <const TNewChildren>(children: Constrain<TNewChildren, ReadonlyArray<AnyRoute> | Record<string, AnyRoute>>) => Route<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TNewChildren, TFileRouteTypes>;
|
||||
export type RouteAddFileChildrenFn<in out TParentRoute extends AnyRoute, in out TPath extends string, in out TFullPath extends string, in out TCustomId extends string, in out TId extends string, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn, in out TLoaderDeps extends Record<string, any>, in out TLoaderFn, in out TFileRouteTypes> = <const TNewChildren>(children: TNewChildren) => Route<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TNewChildren, TFileRouteTypes>;
|
||||
export type RouteAddFileTypesFn<TParentRoute extends AnyRoute, TPath extends string, TFullPath extends string, TCustomId extends string, TId extends string, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps extends Record<string, any>, TLoaderFn, TChildren> = <TNewFileRouteTypes>() => Route<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TNewFileRouteTypes>;
|
||||
export interface Route<in out TParentRoute extends AnyRoute, in out TPath extends string, in out TFullPath extends string, in out TCustomId extends string, in out TId extends string, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn, in out TLoaderDeps extends Record<string, any>, in out TLoaderFn, in out TChildren, in out TFileRouteTypes> extends RouteExtensions<TId, TFullPath> {
|
||||
fullPath: TFullPath;
|
||||
path: TPath;
|
||||
id: TId;
|
||||
parentRoute: TParentRoute;
|
||||
children?: TChildren;
|
||||
types: RouteTypes<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes>;
|
||||
options: RouteOptions<TParentRoute, TId, TCustomId, TFullPath, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn>;
|
||||
isRoot: TParentRoute extends AnyRoute ? true : false;
|
||||
_componentsPromise?: Promise<Array<void>>;
|
||||
lazyFn?: () => Promise<LazyRoute>;
|
||||
_lazyPromise?: Promise<void>;
|
||||
rank: number;
|
||||
to: TrimPathRight<TFullPath>;
|
||||
init: (opts: {
|
||||
originalIndex: number;
|
||||
defaultSsr?: boolean;
|
||||
}) => void;
|
||||
update: (options: UpdatableRouteOptions<TParentRoute, TCustomId, TFullPath, TParams, TSearchValidator, TLoaderFn, TLoaderDeps, TRouterContext, TRouteContextFn, TBeforeLoadFn>) => this;
|
||||
lazy: RouteLazyFn<this>;
|
||||
addChildren: RouteAddChildrenFn<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TFileRouteTypes>;
|
||||
_addFileChildren: RouteAddFileChildrenFn<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TFileRouteTypes>;
|
||||
_addFileTypes: RouteAddFileTypesFn<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren>;
|
||||
}
|
||||
export type AnyRoute = Route<any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
|
||||
export type AnyRouteWithContext<TContext> = AnyRoute & {
|
||||
types: {
|
||||
allContext: TContext;
|
||||
};
|
||||
};
|
||||
export type RouteOptions<TParentRoute extends AnyRoute = AnyRoute, TId extends string = string, TCustomId extends string = string, TFullPath extends string = string, TPath extends string = string, TSearchValidator = undefined, TParams = AnyPathParams, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext> = BaseRouteOptions<TParentRoute, TId, TCustomId, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn> & UpdatableRouteOptions<NoInfer<TParentRoute>, NoInfer<TCustomId>, NoInfer<TFullPath>, NoInfer<TParams>, NoInfer<TSearchValidator>, NoInfer<TLoaderFn>, NoInfer<TLoaderDeps>, NoInfer<TRouterContext>, NoInfer<TRouteContextFn>, NoInfer<TBeforeLoadFn>>;
|
||||
export type RouteContextFn<in out TParentRoute extends AnyRoute, in out TSearchValidator, in out TParams, in out TRouterContext> = (ctx: RouteContextOptions<TParentRoute, TSearchValidator, TParams, TRouterContext>) => any;
|
||||
export type BeforeLoadFn<in out TParentRoute extends AnyRoute, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn> = (ctx: BeforeLoadContextOptions<TParentRoute, TSearchValidator, TParams, TRouterContext, TRouteContextFn>) => any;
|
||||
export type FileBaseRouteOptions<TParentRoute extends AnyRoute = AnyRoute, TId extends string = string, TPath extends string = string, TSearchValidator = undefined, TParams = {}, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TRemountDepsFn = AnyContext> = ParamsOptions<TPath, TParams> & {
|
||||
validateSearch?: Constrain<TSearchValidator, AnyValidator, DefaultValidator>;
|
||||
shouldReload?: boolean | ((match: LoaderFnContext<TParentRoute, TId, TParams, TLoaderDeps, TRouterContext, TRouteContextFn, TBeforeLoadFn>) => any);
|
||||
context?: Constrain<TRouteContextFn, (ctx: RouteContextOptions<TParentRoute, TParams, TRouterContext, TLoaderDeps>) => any>;
|
||||
beforeLoad?: Constrain<TBeforeLoadFn, (ctx: BeforeLoadContextOptions<TParentRoute, TSearchValidator, TParams, TRouterContext, TRouteContextFn>) => any>;
|
||||
loaderDeps?: (opts: FullSearchSchemaOption<TParentRoute, TSearchValidator>) => TLoaderDeps;
|
||||
remountDeps?: Constrain<TRemountDepsFn, (opt: RemountDepsOptions<TId, FullSearchSchemaOption<TParentRoute, TSearchValidator>, Expand<ResolveAllParamsFromParent<TParentRoute, TParams>>, TLoaderDeps>) => any>;
|
||||
loader?: Constrain<TLoaderFn, (ctx: LoaderFnContext<TParentRoute, TId, TParams, TLoaderDeps, TRouterContext, TRouteContextFn, TBeforeLoadFn>) => any>;
|
||||
};
|
||||
export type BaseRouteOptions<TParentRoute extends AnyRoute = AnyRoute, TId extends string = string, TCustomId extends string = string, TPath extends string = string, TSearchValidator = undefined, TParams = {}, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext> = RoutePathOptions<TCustomId, TPath> & FileBaseRouteOptions<TParentRoute, TId, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn> & {
|
||||
getParentRoute: () => TParentRoute;
|
||||
};
|
||||
export interface ContextOptions<in out TParentRoute extends AnyRoute, in out TParams> {
|
||||
abortController: AbortController;
|
||||
preload: boolean;
|
||||
params: Expand<ResolveAllParamsFromParent<TParentRoute, TParams>>;
|
||||
location: ParsedLocation;
|
||||
/**
|
||||
* @deprecated Use `throw redirect({ to: '/somewhere' })` instead
|
||||
**/
|
||||
navigate: NavigateFn;
|
||||
buildLocation: BuildLocationFn;
|
||||
cause: 'preload' | 'enter' | 'stay';
|
||||
matches: Array<MakeRouteMatchUnion>;
|
||||
}
|
||||
export interface RouteContextOptions<in out TParentRoute extends AnyRoute, in out TParams, in out TRouterContext, in out TLoaderDeps> extends ContextOptions<TParentRoute, TParams> {
|
||||
deps: TLoaderDeps;
|
||||
context: Expand<RouteContextParameter<TParentRoute, TRouterContext>>;
|
||||
}
|
||||
export interface BeforeLoadContextOptions<in out TParentRoute extends AnyRoute, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn> extends ContextOptions<TParentRoute, TParams>, FullSearchSchemaOption<TParentRoute, TSearchValidator> {
|
||||
context: Expand<BeforeLoadContextParameter<TParentRoute, TRouterContext, TRouteContextFn>>;
|
||||
}
|
||||
type AssetFnContextOptions<in out TRouteId, in out TFullPath, in out TParentRoute extends AnyRoute, in out TParams, in out TSearchValidator, in out TLoaderFn, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn, in out TLoaderDeps> = {
|
||||
matches: Array<RouteMatch<TRouteId, TFullPath, ResolveAllParamsFromParent<TParentRoute, TParams>, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, ResolveLoaderData<TLoaderFn>, ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>, TLoaderDeps>>;
|
||||
match: RouteMatch<TRouteId, TFullPath, ResolveAllParamsFromParent<TParentRoute, TParams>, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, ResolveLoaderData<TLoaderFn>, ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>, TLoaderDeps>;
|
||||
params: ResolveAllParamsFromParent<TParentRoute, TParams>;
|
||||
loaderData: ResolveLoaderData<TLoaderFn>;
|
||||
};
|
||||
export interface DefaultUpdatableRouteOptionsExtensions {
|
||||
component?: unknown;
|
||||
errorComponent?: unknown;
|
||||
notFoundComponent?: unknown;
|
||||
pendingComponent?: unknown;
|
||||
}
|
||||
export interface UpdatableRouteOptionsExtensions extends DefaultUpdatableRouteOptionsExtensions {
|
||||
}
|
||||
export interface UpdatableRouteOptions<in out TParentRoute extends AnyRoute, in out TRouteId, in out TFullPath, in out TParams, in out TSearchValidator, in out TLoaderFn, in out TLoaderDeps, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn> extends UpdatableStaticRouteOption, UpdatableRouteOptionsExtensions {
|
||||
caseSensitive?: boolean;
|
||||
wrapInSuspense?: boolean;
|
||||
pendingMs?: number;
|
||||
pendingMinMs?: number;
|
||||
staleTime?: number;
|
||||
gcTime?: number;
|
||||
preload?: boolean;
|
||||
preloadStaleTime?: number;
|
||||
preloadGcTime?: number;
|
||||
search?: {
|
||||
middlewares?: Array<SearchMiddleware<ResolveFullSearchSchemaInput<TParentRoute, TSearchValidator>>>;
|
||||
};
|
||||
/**
|
||||
@deprecated Use search.middlewares instead
|
||||
*/
|
||||
preSearchFilters?: Array<SearchFilter<ResolveFullSearchSchema<TParentRoute, TSearchValidator>>>;
|
||||
/**
|
||||
@deprecated Use search.middlewares instead
|
||||
*/
|
||||
postSearchFilters?: Array<SearchFilter<ResolveFullSearchSchema<TParentRoute, TSearchValidator>>>;
|
||||
onCatch?: (error: Error) => void;
|
||||
onError?: (err: any) => void;
|
||||
onEnter?: (match: RouteMatch<TRouteId, TFullPath, ResolveAllParamsFromParent<TParentRoute, TParams>, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, ResolveLoaderData<TLoaderFn>, ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>, TLoaderDeps>) => void;
|
||||
onStay?: (match: RouteMatch<TRouteId, TFullPath, ResolveAllParamsFromParent<TParentRoute, TParams>, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, ResolveLoaderData<TLoaderFn>, ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>, TLoaderDeps>) => void;
|
||||
onLeave?: (match: RouteMatch<TRouteId, TFullPath, ResolveAllParamsFromParent<TParentRoute, TParams>, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, ResolveLoaderData<TLoaderFn>, ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>, TLoaderDeps>) => void;
|
||||
headers?: (ctx: {
|
||||
loaderData: ResolveLoaderData<TLoaderFn>;
|
||||
}) => Record<string, string>;
|
||||
head?: (ctx: AssetFnContextOptions<TRouteId, TFullPath, TParentRoute, TParams, TSearchValidator, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps>) => {
|
||||
links?: AnyRouteMatch['links'];
|
||||
scripts?: AnyRouteMatch['headScripts'];
|
||||
meta?: AnyRouteMatch['meta'];
|
||||
};
|
||||
scripts?: (ctx: AssetFnContextOptions<TRouteId, TFullPath, TParentRoute, TParams, TSearchValidator, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps>) => AnyRouteMatch['scripts'];
|
||||
ssr?: boolean;
|
||||
codeSplitGroupings?: Array<Array<'loader' | 'component' | 'pendingComponent' | 'notFoundComponent' | 'errorComponent'>>;
|
||||
}
|
||||
export type RouteLoaderFn<in out TParentRoute extends AnyRoute = AnyRoute, in out TId extends string = string, in out TParams = {}, in out TLoaderDeps = {}, in out TRouterContext = {}, in out TRouteContextFn = AnyContext, in out TBeforeLoadFn = AnyContext> = (match: LoaderFnContext<TParentRoute, TId, TParams, TLoaderDeps, TRouterContext, TRouteContextFn, TBeforeLoadFn>) => any;
|
||||
export interface LoaderFnContext<in out TParentRoute extends AnyRoute = AnyRoute, in out TId extends string = string, in out TParams = {}, in out TLoaderDeps = {}, in out TRouterContext = {}, in out TRouteContextFn = AnyContext, in out TBeforeLoadFn = AnyContext> {
|
||||
abortController: AbortController;
|
||||
preload: boolean;
|
||||
params: Expand<ResolveAllParamsFromParent<TParentRoute, TParams>>;
|
||||
deps: TLoaderDeps;
|
||||
context: Expand<ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>>;
|
||||
location: ParsedLocation;
|
||||
/**
|
||||
* @deprecated Use `throw redirect({ to: '/somewhere' })` instead
|
||||
**/
|
||||
navigate: (opts: NavigateOptions<AnyRouter>) => Promise<void> | void;
|
||||
parentMatchPromise: TId extends RootRouteId ? never : Promise<MakeRouteMatchFromRoute<TParentRoute>>;
|
||||
cause: 'preload' | 'enter' | 'stay';
|
||||
route: AnyRoute;
|
||||
}
|
||||
export type RootRouteOptions<TSearchValidator = undefined, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined> = Omit<RouteOptions<any, // TParentRoute
|
||||
RootRouteId, // TId
|
||||
RootRouteId, // TCustomId
|
||||
'', // TFullPath
|
||||
'', // TPath
|
||||
TSearchValidator, {}, // TParams
|
||||
TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn>, 'path' | 'id' | 'getParentRoute' | 'caseSensitive' | 'parseParams' | 'stringifyParams' | 'params'>;
|
||||
export type RouteConstraints = {
|
||||
TParentRoute: AnyRoute;
|
||||
TPath: string;
|
||||
TFullPath: string;
|
||||
TCustomId: string;
|
||||
TId: string;
|
||||
TSearchSchema: AnySchema;
|
||||
TFullSearchSchema: AnySchema;
|
||||
TParams: Record<string, any>;
|
||||
TAllParams: Record<string, any>;
|
||||
TParentContext: AnyContext;
|
||||
TRouteContext: RouteContext;
|
||||
TAllContext: AnyContext;
|
||||
TRouterContext: AnyContext;
|
||||
TChildren: unknown;
|
||||
TRouteTree: AnyRoute;
|
||||
};
|
||||
export type RouteTypesById<TRouter extends AnyRouter, TId> = RouteById<TRouter['routeTree'], TId>['types'];
|
||||
export type RouteMask<TRouteTree extends AnyRoute> = {
|
||||
routeTree: TRouteTree;
|
||||
from: RoutePaths<TRouteTree>;
|
||||
to?: any;
|
||||
params?: any;
|
||||
search?: any;
|
||||
hash?: any;
|
||||
state?: any;
|
||||
unmaskOnReload?: boolean;
|
||||
};
|
||||
/**
|
||||
* @deprecated Use `ErrorComponentProps` instead.
|
||||
*/
|
||||
export type ErrorRouteProps = {
|
||||
error: unknown;
|
||||
info?: {
|
||||
componentStack: string;
|
||||
};
|
||||
reset: () => void;
|
||||
};
|
||||
export type ErrorComponentProps = {
|
||||
error: Error;
|
||||
info?: {
|
||||
componentStack: string;
|
||||
};
|
||||
reset: () => void;
|
||||
};
|
||||
export type NotFoundRouteProps = {
|
||||
data: unknown;
|
||||
};
|
||||
export declare class BaseRoute<in out TParentRoute extends AnyRoute = AnyRoute, in out TPath extends string = '/', in out TFullPath extends string = ResolveFullPath<TParentRoute, TPath>, in out TCustomId extends string = string, in out TId extends string = ResolveId<TParentRoute, TCustomId, TPath>, in out TSearchValidator = undefined, in out TParams = ResolveParams<TPath>, in out TRouterContext = AnyContext, in out TRouteContextFn = AnyContext, in out TBeforeLoadFn = AnyContext, in out TLoaderDeps extends Record<string, any> = {}, in out TLoaderFn = undefined, in out TChildren = unknown, in out TFileRouteTypes = unknown> implements Route<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes> {
|
||||
isRoot: TParentRoute extends AnyRoute ? true : false;
|
||||
options: RouteOptions<TParentRoute, TId, TCustomId, TFullPath, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn>;
|
||||
parentRoute: TParentRoute;
|
||||
private _id;
|
||||
private _path;
|
||||
private _fullPath;
|
||||
private _to;
|
||||
private _ssr;
|
||||
get to(): TrimPathRight<TFullPath>;
|
||||
get id(): TId;
|
||||
get path(): TPath;
|
||||
get fullPath(): TFullPath;
|
||||
get ssr(): boolean;
|
||||
children?: TChildren;
|
||||
originalIndex?: number;
|
||||
rank: number;
|
||||
lazyFn?: () => Promise<LazyRoute>;
|
||||
_lazyPromise?: Promise<void>;
|
||||
_componentsPromise?: Promise<Array<void>>;
|
||||
constructor(options?: RouteOptions<TParentRoute, TId, TCustomId, TFullPath, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn>);
|
||||
types: RouteTypes<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes>;
|
||||
init: (opts: {
|
||||
originalIndex: number;
|
||||
defaultSsr?: boolean;
|
||||
}) => void;
|
||||
addChildren: RouteAddChildrenFn<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TFileRouteTypes>;
|
||||
_addFileChildren: RouteAddFileChildrenFn<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TFileRouteTypes>;
|
||||
_addFileTypes: RouteAddFileTypesFn<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren>;
|
||||
updateLoader: <TNewLoaderFn>(options: {
|
||||
loader: Constrain<TNewLoaderFn, RouteLoaderFn<TParentRoute, TCustomId, TParams, TLoaderDeps, TRouterContext, TRouteContextFn, TBeforeLoadFn>>;
|
||||
}) => BaseRoute<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TNewLoaderFn, TChildren, TFileRouteTypes>;
|
||||
update: (options: UpdatableRouteOptions<TParentRoute, TCustomId, TFullPath, TParams, TSearchValidator, TLoaderFn, TLoaderDeps, TRouterContext, TRouteContextFn, TBeforeLoadFn>) => this;
|
||||
lazy: RouteLazyFn<this>;
|
||||
}
|
||||
export declare class BaseRouteApi<TId, TRouter extends AnyRouter = RegisteredRouter> {
|
||||
id: TId;
|
||||
constructor({ id }: {
|
||||
id: TId;
|
||||
});
|
||||
notFound: (opts?: NotFoundError) => NotFoundError;
|
||||
}
|
||||
export declare class BaseRootRoute<in out TSearchValidator = undefined, in out TRouterContext = {}, in out TRouteContextFn = AnyContext, in out TBeforeLoadFn = AnyContext, in out TLoaderDeps extends Record<string, any> = {}, in out TLoaderFn = undefined, in out TChildren = unknown, in out TFileRouteTypes = unknown> extends BaseRoute<any, // TParentRoute
|
||||
'/', // TPath
|
||||
'/', // TFullPath
|
||||
string, // TCustomId
|
||||
RootRouteId, // TId
|
||||
TSearchValidator, // TSearchValidator
|
||||
{}, // TParams
|
||||
TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, // TChildren
|
||||
TFileRouteTypes> {
|
||||
constructor(options?: RootRouteOptions<TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn>);
|
||||
}
|
||||
export {};
|
||||
@@ -0,0 +1,12 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = inheritTrailingComments;
|
||||
var _inherit = require("../utils/inherit.js");
|
||||
function inheritTrailingComments(child, parent) {
|
||||
(0, _inherit.default)("trailingComments", child, parent);
|
||||
}
|
||||
|
||||
//# sourceMappingURL=inheritTrailingComments.js.map
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,387 @@
|
||||
'use strict';
|
||||
|
||||
var resolve = require('./resolve')
|
||||
, util = require('./util')
|
||||
, errorClasses = require('./error_classes')
|
||||
, stableStringify = require('fast-json-stable-stringify');
|
||||
|
||||
var validateGenerator = require('../dotjs/validate');
|
||||
|
||||
/**
|
||||
* Functions below are used inside compiled validations function
|
||||
*/
|
||||
|
||||
var ucs2length = util.ucs2length;
|
||||
var equal = require('fast-deep-equal');
|
||||
|
||||
// this error is thrown by async schemas to return validation errors via exception
|
||||
var ValidationError = errorClasses.Validation;
|
||||
|
||||
module.exports = compile;
|
||||
|
||||
|
||||
/**
|
||||
* Compiles schema to validation function
|
||||
* @this Ajv
|
||||
* @param {Object} schema schema object
|
||||
* @param {Object} root object with information about the root schema for this schema
|
||||
* @param {Object} localRefs the hash of local references inside the schema (created by resolve.id), used for inline resolution
|
||||
* @param {String} baseId base ID for IDs in the schema
|
||||
* @return {Function} validation function
|
||||
*/
|
||||
function compile(schema, root, localRefs, baseId) {
|
||||
/* jshint validthis: true, evil: true */
|
||||
/* eslint no-shadow: 0 */
|
||||
var self = this
|
||||
, opts = this._opts
|
||||
, refVal = [ undefined ]
|
||||
, refs = {}
|
||||
, patterns = []
|
||||
, patternsHash = {}
|
||||
, defaults = []
|
||||
, defaultsHash = {}
|
||||
, customRules = [];
|
||||
|
||||
root = root || { schema: schema, refVal: refVal, refs: refs };
|
||||
|
||||
var c = checkCompiling.call(this, schema, root, baseId);
|
||||
var compilation = this._compilations[c.index];
|
||||
if (c.compiling) return (compilation.callValidate = callValidate);
|
||||
|
||||
var formats = this._formats;
|
||||
var RULES = this.RULES;
|
||||
|
||||
try {
|
||||
var v = localCompile(schema, root, localRefs, baseId);
|
||||
compilation.validate = v;
|
||||
var cv = compilation.callValidate;
|
||||
if (cv) {
|
||||
cv.schema = v.schema;
|
||||
cv.errors = null;
|
||||
cv.refs = v.refs;
|
||||
cv.refVal = v.refVal;
|
||||
cv.root = v.root;
|
||||
cv.$async = v.$async;
|
||||
if (opts.sourceCode) cv.source = v.source;
|
||||
}
|
||||
return v;
|
||||
} finally {
|
||||
endCompiling.call(this, schema, root, baseId);
|
||||
}
|
||||
|
||||
/* @this {*} - custom context, see passContext option */
|
||||
function callValidate() {
|
||||
/* jshint validthis: true */
|
||||
var validate = compilation.validate;
|
||||
var result = validate.apply(this, arguments);
|
||||
callValidate.errors = validate.errors;
|
||||
return result;
|
||||
}
|
||||
|
||||
function localCompile(_schema, _root, localRefs, baseId) {
|
||||
var isRoot = !_root || (_root && _root.schema == _schema);
|
||||
if (_root.schema != root.schema)
|
||||
return compile.call(self, _schema, _root, localRefs, baseId);
|
||||
|
||||
var $async = _schema.$async === true;
|
||||
|
||||
var sourceCode = validateGenerator({
|
||||
isTop: true,
|
||||
schema: _schema,
|
||||
isRoot: isRoot,
|
||||
baseId: baseId,
|
||||
root: _root,
|
||||
schemaPath: '',
|
||||
errSchemaPath: '#',
|
||||
errorPath: '""',
|
||||
MissingRefError: errorClasses.MissingRef,
|
||||
RULES: RULES,
|
||||
validate: validateGenerator,
|
||||
util: util,
|
||||
resolve: resolve,
|
||||
resolveRef: resolveRef,
|
||||
usePattern: usePattern,
|
||||
useDefault: useDefault,
|
||||
useCustomRule: useCustomRule,
|
||||
opts: opts,
|
||||
formats: formats,
|
||||
logger: self.logger,
|
||||
self: self
|
||||
});
|
||||
|
||||
sourceCode = vars(refVal, refValCode) + vars(patterns, patternCode)
|
||||
+ vars(defaults, defaultCode) + vars(customRules, customRuleCode)
|
||||
+ sourceCode;
|
||||
|
||||
if (opts.processCode) sourceCode = opts.processCode(sourceCode, _schema);
|
||||
// console.log('\n\n\n *** \n', JSON.stringify(sourceCode));
|
||||
var validate;
|
||||
try {
|
||||
var makeValidate = new Function(
|
||||
'self',
|
||||
'RULES',
|
||||
'formats',
|
||||
'root',
|
||||
'refVal',
|
||||
'defaults',
|
||||
'customRules',
|
||||
'equal',
|
||||
'ucs2length',
|
||||
'ValidationError',
|
||||
sourceCode
|
||||
);
|
||||
|
||||
validate = makeValidate(
|
||||
self,
|
||||
RULES,
|
||||
formats,
|
||||
root,
|
||||
refVal,
|
||||
defaults,
|
||||
customRules,
|
||||
equal,
|
||||
ucs2length,
|
||||
ValidationError
|
||||
);
|
||||
|
||||
refVal[0] = validate;
|
||||
} catch(e) {
|
||||
self.logger.error('Error compiling schema, function code:', sourceCode);
|
||||
throw e;
|
||||
}
|
||||
|
||||
validate.schema = _schema;
|
||||
validate.errors = null;
|
||||
validate.refs = refs;
|
||||
validate.refVal = refVal;
|
||||
validate.root = isRoot ? validate : _root;
|
||||
if ($async) validate.$async = true;
|
||||
if (opts.sourceCode === true) {
|
||||
validate.source = {
|
||||
code: sourceCode,
|
||||
patterns: patterns,
|
||||
defaults: defaults
|
||||
};
|
||||
}
|
||||
|
||||
return validate;
|
||||
}
|
||||
|
||||
function resolveRef(baseId, ref, isRoot) {
|
||||
ref = resolve.url(baseId, ref);
|
||||
var refIndex = refs[ref];
|
||||
var _refVal, refCode;
|
||||
if (refIndex !== undefined) {
|
||||
_refVal = refVal[refIndex];
|
||||
refCode = 'refVal[' + refIndex + ']';
|
||||
return resolvedRef(_refVal, refCode);
|
||||
}
|
||||
if (!isRoot && root.refs) {
|
||||
var rootRefId = root.refs[ref];
|
||||
if (rootRefId !== undefined) {
|
||||
_refVal = root.refVal[rootRefId];
|
||||
refCode = addLocalRef(ref, _refVal);
|
||||
return resolvedRef(_refVal, refCode);
|
||||
}
|
||||
}
|
||||
|
||||
refCode = addLocalRef(ref);
|
||||
var v = resolve.call(self, localCompile, root, ref);
|
||||
if (v === undefined) {
|
||||
var localSchema = localRefs && localRefs[ref];
|
||||
if (localSchema) {
|
||||
v = resolve.inlineRef(localSchema, opts.inlineRefs)
|
||||
? localSchema
|
||||
: compile.call(self, localSchema, root, localRefs, baseId);
|
||||
}
|
||||
}
|
||||
|
||||
if (v === undefined) {
|
||||
removeLocalRef(ref);
|
||||
} else {
|
||||
replaceLocalRef(ref, v);
|
||||
return resolvedRef(v, refCode);
|
||||
}
|
||||
}
|
||||
|
||||
function addLocalRef(ref, v) {
|
||||
var refId = refVal.length;
|
||||
refVal[refId] = v;
|
||||
refs[ref] = refId;
|
||||
return 'refVal' + refId;
|
||||
}
|
||||
|
||||
function removeLocalRef(ref) {
|
||||
delete refs[ref];
|
||||
}
|
||||
|
||||
function replaceLocalRef(ref, v) {
|
||||
var refId = refs[ref];
|
||||
refVal[refId] = v;
|
||||
}
|
||||
|
||||
function resolvedRef(refVal, code) {
|
||||
return typeof refVal == 'object' || typeof refVal == 'boolean'
|
||||
? { code: code, schema: refVal, inline: true }
|
||||
: { code: code, $async: refVal && !!refVal.$async };
|
||||
}
|
||||
|
||||
function usePattern(regexStr) {
|
||||
var index = patternsHash[regexStr];
|
||||
if (index === undefined) {
|
||||
index = patternsHash[regexStr] = patterns.length;
|
||||
patterns[index] = regexStr;
|
||||
}
|
||||
return 'pattern' + index;
|
||||
}
|
||||
|
||||
function useDefault(value) {
|
||||
switch (typeof value) {
|
||||
case 'boolean':
|
||||
case 'number':
|
||||
return '' + value;
|
||||
case 'string':
|
||||
return util.toQuotedString(value);
|
||||
case 'object':
|
||||
if (value === null) return 'null';
|
||||
var valueStr = stableStringify(value);
|
||||
var index = defaultsHash[valueStr];
|
||||
if (index === undefined) {
|
||||
index = defaultsHash[valueStr] = defaults.length;
|
||||
defaults[index] = value;
|
||||
}
|
||||
return 'default' + index;
|
||||
}
|
||||
}
|
||||
|
||||
function useCustomRule(rule, schema, parentSchema, it) {
|
||||
if (self._opts.validateSchema !== false) {
|
||||
var deps = rule.definition.dependencies;
|
||||
if (deps && !deps.every(function(keyword) {
|
||||
return Object.prototype.hasOwnProperty.call(parentSchema, keyword);
|
||||
}))
|
||||
throw new Error('parent schema must have all required keywords: ' + deps.join(','));
|
||||
|
||||
var validateSchema = rule.definition.validateSchema;
|
||||
if (validateSchema) {
|
||||
var valid = validateSchema(schema);
|
||||
if (!valid) {
|
||||
var message = 'keyword schema is invalid: ' + self.errorsText(validateSchema.errors);
|
||||
if (self._opts.validateSchema == 'log') self.logger.error(message);
|
||||
else throw new Error(message);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var compile = rule.definition.compile
|
||||
, inline = rule.definition.inline
|
||||
, macro = rule.definition.macro;
|
||||
|
||||
var validate;
|
||||
if (compile) {
|
||||
validate = compile.call(self, schema, parentSchema, it);
|
||||
} else if (macro) {
|
||||
validate = macro.call(self, schema, parentSchema, it);
|
||||
if (opts.validateSchema !== false) self.validateSchema(validate, true);
|
||||
} else if (inline) {
|
||||
validate = inline.call(self, it, rule.keyword, schema, parentSchema);
|
||||
} else {
|
||||
validate = rule.definition.validate;
|
||||
if (!validate) return;
|
||||
}
|
||||
|
||||
if (validate === undefined)
|
||||
throw new Error('custom keyword "' + rule.keyword + '"failed to compile');
|
||||
|
||||
var index = customRules.length;
|
||||
customRules[index] = validate;
|
||||
|
||||
return {
|
||||
code: 'customRule' + index,
|
||||
validate: validate
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Checks if the schema is currently compiled
|
||||
* @this Ajv
|
||||
* @param {Object} schema schema to compile
|
||||
* @param {Object} root root object
|
||||
* @param {String} baseId base schema ID
|
||||
* @return {Object} object with properties "index" (compilation index) and "compiling" (boolean)
|
||||
*/
|
||||
function checkCompiling(schema, root, baseId) {
|
||||
/* jshint validthis: true */
|
||||
var index = compIndex.call(this, schema, root, baseId);
|
||||
if (index >= 0) return { index: index, compiling: true };
|
||||
index = this._compilations.length;
|
||||
this._compilations[index] = {
|
||||
schema: schema,
|
||||
root: root,
|
||||
baseId: baseId
|
||||
};
|
||||
return { index: index, compiling: false };
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Removes the schema from the currently compiled list
|
||||
* @this Ajv
|
||||
* @param {Object} schema schema to compile
|
||||
* @param {Object} root root object
|
||||
* @param {String} baseId base schema ID
|
||||
*/
|
||||
function endCompiling(schema, root, baseId) {
|
||||
/* jshint validthis: true */
|
||||
var i = compIndex.call(this, schema, root, baseId);
|
||||
if (i >= 0) this._compilations.splice(i, 1);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Index of schema compilation in the currently compiled list
|
||||
* @this Ajv
|
||||
* @param {Object} schema schema to compile
|
||||
* @param {Object} root root object
|
||||
* @param {String} baseId base schema ID
|
||||
* @return {Integer} compilation index
|
||||
*/
|
||||
function compIndex(schema, root, baseId) {
|
||||
/* jshint validthis: true */
|
||||
for (var i=0; i<this._compilations.length; i++) {
|
||||
var c = this._compilations[i];
|
||||
if (c.schema == schema && c.root == root && c.baseId == baseId) return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
function patternCode(i, patterns) {
|
||||
return 'var pattern' + i + ' = new RegExp(' + util.toQuotedString(patterns[i]) + ');';
|
||||
}
|
||||
|
||||
|
||||
function defaultCode(i) {
|
||||
return 'var default' + i + ' = defaults[' + i + '];';
|
||||
}
|
||||
|
||||
|
||||
function refValCode(i, refVal) {
|
||||
return refVal[i] === undefined ? '' : 'var refVal' + i + ' = refVal[' + i + '];';
|
||||
}
|
||||
|
||||
|
||||
function customRuleCode(i) {
|
||||
return 'var customRule' + i + ' = customRules[' + i + '];';
|
||||
}
|
||||
|
||||
|
||||
function vars(arr, statement) {
|
||||
if (!arr.length) return '';
|
||||
var code = '';
|
||||
for (var i=0; i<arr.length; i++)
|
||||
code += statement(i, arr);
|
||||
return code;
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"K D E F A B mC"},B:{"2":"0 9 C L M G N O P Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I"},C:{"2":"0 1 2 3 4 5 6 7 8 9 nC LC J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC oC pC qC rC"},D:{"2":"1 2 3 4 5 6 7 8 J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB","194":"0 9 vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC"},E:{"2":"J PB K D E F A B C L M G sC SC tC uC vC wC TC FC GC xC yC zC UC VC HC 0C IC WC XC YC ZC aC 1C JC bC cC dC eC fC 2C KC gC hC iC jC 3C"},F:{"2":"1 2 3 4 5 6 7 8 F B C G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB 4C 5C 6C 7C FC kC 8C GC","194":"0 hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z"},G:{"2":"E SC 9C lC AD BD CD DD ED FD GD HD ID JD KD LD MD ND OD PD QD RD SD UC VC HC TD IC WC XC YC ZC aC UD JC bC cC dC eC fC VD KC gC hC iC jC"},H:{"2":"WD"},I:{"2":"LC J I XD YD ZD aD lC bD cD"},J:{"2":"D A"},K:{"2":"A B C H FC kC GC"},L:{"194":"I"},M:{"2":"EC"},N:{"2":"A B"},O:{"2":"HC"},P:{"2":"1 2 3 4 5 6 7 8 J dD eD fD gD hD TC iD jD kD lD mD IC JC KC nD"},Q:{"2":"oD"},R:{"2":"pD"},S:{"2":"qD rD"}},B:4,C:"Magnetometer",D:true};
|
||||
@@ -0,0 +1,47 @@
|
||||
import type { PDFDocumentProxy } from 'pdfjs-dist';
|
||||
import type { EventProps } from 'make-event-props';
|
||||
import type { ClassName, OnItemClickArgs } from './shared/types.js';
|
||||
type PDFOutline = Awaited<ReturnType<PDFDocumentProxy['getOutline']>>;
|
||||
export type OutlineProps = {
|
||||
/**
|
||||
* Class name(s) that will be added to rendered element along with the default `react-pdf__Outline`.
|
||||
*
|
||||
* @example 'custom-class-name-1 custom-class-name-2'
|
||||
* @example ['custom-class-name-1', 'custom-class-name-2']
|
||||
*/
|
||||
className?: ClassName;
|
||||
/**
|
||||
* A prop that behaves like [ref](https://reactjs.org/docs/refs-and-the-dom.html), but it's passed to main `<div>` rendered by `<Outline>` component.
|
||||
*
|
||||
* @example (ref) => { this.myOutline = ref; }
|
||||
* @example this.ref
|
||||
* @example ref
|
||||
*/
|
||||
inputRef?: React.Ref<HTMLDivElement>;
|
||||
/**
|
||||
* Function called when an outline item has been clicked. Usually, you would like to use this callback to move the user wherever they requested to.
|
||||
*
|
||||
* @example ({ dest, pageIndex, pageNumber }) => alert('Clicked an item from page ' + pageNumber + '!')
|
||||
*/
|
||||
onItemClick?: (props: OnItemClickArgs) => void;
|
||||
/**
|
||||
* Function called in case of an error while retrieving the outline.
|
||||
*
|
||||
* @example (error) => alert('Error while retrieving the outline! ' + error.message)
|
||||
*/
|
||||
onLoadError?: (error: Error) => void;
|
||||
/**
|
||||
* Function called when the outline is successfully retrieved.
|
||||
*
|
||||
* @example (outline) => alert('The outline has been successfully retrieved.')
|
||||
*/
|
||||
onLoadSuccess?: (outline: PDFOutline | null) => void;
|
||||
pdf?: PDFDocumentProxy | false;
|
||||
} & EventProps<PDFOutline | null | false | undefined>;
|
||||
/**
|
||||
* Displays an outline (table of contents).
|
||||
*
|
||||
* Should be placed inside `<Document />`. Alternatively, it can have `pdf` prop passed, which can be obtained from `<Document />`'s `onLoadSuccess` callback function.
|
||||
*/
|
||||
export default function Outline(props: OutlineProps): React.ReactElement | null;
|
||||
export {};
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user