update
This commit is contained in:
@@ -0,0 +1,9 @@
|
||||
{{# def.definitions }}
|
||||
{{# def.setupKeyword }}
|
||||
|
||||
{{ var $comment = it.util.toQuotedString($schema); }}
|
||||
{{? it.opts.$comment === true }}
|
||||
console.log({{=$comment}});
|
||||
{{?? typeof it.opts.$comment == 'function' }}
|
||||
self._opts.$comment({{=$comment}}, {{=it.util.toQuotedString($errSchemaPath)}}, validate.root.schema);
|
||||
{{?}}
|
||||
@@ -0,0 +1,47 @@
|
||||
import type {
|
||||
AnyRouter,
|
||||
Constrain,
|
||||
OptionalStructuralSharing,
|
||||
ValidateJSON,
|
||||
} from '@tanstack/router-core'
|
||||
|
||||
export type DefaultStructuralSharingEnabled<TRouter extends AnyRouter> =
|
||||
boolean extends TRouter['options']['defaultStructuralSharing']
|
||||
? // for now, default to false.
|
||||
// TODO in V2: default to true
|
||||
false
|
||||
: NonNullable<TRouter['options']['defaultStructuralSharing']>
|
||||
|
||||
export interface RequiredStructuralSharing<TStructuralSharing, TConstraint> {
|
||||
readonly structuralSharing: Constrain<TStructuralSharing, TConstraint>
|
||||
}
|
||||
|
||||
export type StructuralSharingOption<
|
||||
TRouter extends AnyRouter,
|
||||
TSelected,
|
||||
TStructuralSharing,
|
||||
> = unknown extends TSelected
|
||||
? OptionalStructuralSharing<TStructuralSharing, boolean>
|
||||
: unknown extends TRouter['routeTree']
|
||||
? OptionalStructuralSharing<TStructuralSharing, boolean>
|
||||
: TSelected extends ValidateJSON<TSelected>
|
||||
? OptionalStructuralSharing<TStructuralSharing, boolean>
|
||||
: DefaultStructuralSharingEnabled<TRouter> extends true
|
||||
? RequiredStructuralSharing<TStructuralSharing, false>
|
||||
: OptionalStructuralSharing<TStructuralSharing, false>
|
||||
|
||||
export type StructuralSharingEnabled<
|
||||
TRouter extends AnyRouter,
|
||||
TStructuralSharing,
|
||||
> = boolean extends TStructuralSharing
|
||||
? DefaultStructuralSharingEnabled<TRouter>
|
||||
: TStructuralSharing
|
||||
|
||||
export type ValidateSelected<
|
||||
TRouter extends AnyRouter,
|
||||
TSelected,
|
||||
TStructuralSharing,
|
||||
> =
|
||||
StructuralSharingEnabled<TRouter, TStructuralSharing> extends true
|
||||
? ValidateJSON<TSelected>
|
||||
: TSelected
|
||||
@@ -0,0 +1,413 @@
|
||||
/**
|
||||
* @fileoverview A helper that translates context.report() calls from the rule API into generic problem objects
|
||||
* @author Teddy Katz
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const assert = require("../shared/assert");
|
||||
const { RuleFixer } = require("./rule-fixer");
|
||||
const { interpolate } = require("./interpolate");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Typedefs
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @typedef {import("../shared/types").LintMessage} LintMessage */
|
||||
|
||||
/**
|
||||
* An error message description
|
||||
* @typedef {Object} MessageDescriptor
|
||||
* @property {ASTNode} [node] The reported node
|
||||
* @property {Location} loc The location of the problem.
|
||||
* @property {string} message The problem message.
|
||||
* @property {Object} [data] Optional data to use to fill in placeholders in the
|
||||
* message.
|
||||
* @property {Function} [fix] The function to call that creates a fix command.
|
||||
* @property {Array<{desc?: string, messageId?: string, fix: Function}>} suggest Suggestion descriptions and functions to create a the associated fixes.
|
||||
*/
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Module Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Translates a multi-argument context.report() call into a single object argument call
|
||||
* @param {...*} args A list of arguments passed to `context.report`
|
||||
* @returns {MessageDescriptor} A normalized object containing report information
|
||||
*/
|
||||
function normalizeMultiArgReportCall(...args) {
|
||||
// If there is one argument, it is considered to be a new-style call already.
|
||||
if (args.length === 1) {
|
||||
// Shallow clone the object to avoid surprises if reusing the descriptor
|
||||
return Object.assign({}, args[0]);
|
||||
}
|
||||
|
||||
// If the second argument is a string, the arguments are interpreted as [node, message, data, fix].
|
||||
if (typeof args[1] === "string") {
|
||||
return {
|
||||
node: args[0],
|
||||
message: args[1],
|
||||
data: args[2],
|
||||
fix: args[3],
|
||||
};
|
||||
}
|
||||
|
||||
// Otherwise, the arguments are interpreted as [node, loc, message, data, fix].
|
||||
return {
|
||||
node: args[0],
|
||||
loc: args[1],
|
||||
message: args[2],
|
||||
data: args[3],
|
||||
fix: args[4],
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that either a loc or a node was provided, and the node is valid if it was provided.
|
||||
* @param {MessageDescriptor} descriptor A descriptor to validate
|
||||
* @returns {void}
|
||||
* @throws AssertionError if neither a node nor a loc was provided, or if the node is not an object
|
||||
*/
|
||||
function assertValidNodeInfo(descriptor) {
|
||||
if (descriptor.node) {
|
||||
assert(typeof descriptor.node === "object", "Node must be an object");
|
||||
} else {
|
||||
assert(
|
||||
descriptor.loc,
|
||||
"Node must be provided when reporting error if location is not provided",
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalizes a MessageDescriptor to always have a `loc` with `start` and `end` properties
|
||||
* @param {MessageDescriptor} descriptor A descriptor for the report from a rule.
|
||||
* @returns {{start: Location, end: (Location|null)}} An updated location that infers the `start` and `end` properties
|
||||
* from the `node` of the original descriptor, or infers the `start` from the `loc` of the original descriptor.
|
||||
*/
|
||||
function normalizeReportLoc(descriptor) {
|
||||
if (descriptor.loc.start) {
|
||||
return descriptor.loc;
|
||||
}
|
||||
return { start: descriptor.loc, end: null };
|
||||
}
|
||||
|
||||
/**
|
||||
* Clones the given fix object.
|
||||
* @param {Fix|null} fix The fix to clone.
|
||||
* @returns {Fix|null} Deep cloned fix object or `null` if `null` or `undefined` was passed in.
|
||||
*/
|
||||
function cloneFix(fix) {
|
||||
if (!fix) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return {
|
||||
range: [fix.range[0], fix.range[1]],
|
||||
text: fix.text,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Check that a fix has a valid range.
|
||||
* @param {Fix|null} fix The fix to validate.
|
||||
* @returns {void}
|
||||
*/
|
||||
function assertValidFix(fix) {
|
||||
if (fix) {
|
||||
assert(
|
||||
fix.range &&
|
||||
typeof fix.range[0] === "number" &&
|
||||
typeof fix.range[1] === "number",
|
||||
`Fix has invalid range: ${JSON.stringify(fix, null, 2)}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Compares items in a fixes array by range.
|
||||
* @param {Fix} a The first message.
|
||||
* @param {Fix} b The second message.
|
||||
* @returns {int} -1 if a comes before b, 1 if a comes after b, 0 if equal.
|
||||
* @private
|
||||
*/
|
||||
function compareFixesByRange(a, b) {
|
||||
return a.range[0] - b.range[0] || a.range[1] - b.range[1];
|
||||
}
|
||||
|
||||
/**
|
||||
* Merges the given fixes array into one.
|
||||
* @param {Fix[]} fixes The fixes to merge.
|
||||
* @param {SourceCode} sourceCode The source code object to get the text between fixes.
|
||||
* @returns {{text: string, range: number[]}} The merged fixes
|
||||
*/
|
||||
function mergeFixes(fixes, sourceCode) {
|
||||
for (const fix of fixes) {
|
||||
assertValidFix(fix);
|
||||
}
|
||||
|
||||
if (fixes.length === 0) {
|
||||
return null;
|
||||
}
|
||||
if (fixes.length === 1) {
|
||||
return cloneFix(fixes[0]);
|
||||
}
|
||||
|
||||
fixes.sort(compareFixesByRange);
|
||||
|
||||
const originalText = sourceCode.text;
|
||||
const start = fixes[0].range[0];
|
||||
const end = fixes.at(-1).range[1];
|
||||
let text = "";
|
||||
let lastPos = Number.MIN_SAFE_INTEGER;
|
||||
|
||||
for (const fix of fixes) {
|
||||
assert(
|
||||
fix.range[0] >= lastPos,
|
||||
"Fix objects must not be overlapped in a report.",
|
||||
);
|
||||
|
||||
if (fix.range[0] >= 0) {
|
||||
text += originalText.slice(
|
||||
Math.max(0, start, lastPos),
|
||||
fix.range[0],
|
||||
);
|
||||
}
|
||||
text += fix.text;
|
||||
lastPos = fix.range[1];
|
||||
}
|
||||
text += originalText.slice(Math.max(0, start, lastPos), end);
|
||||
|
||||
return { range: [start, end], text };
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets one fix object from the given descriptor.
|
||||
* If the descriptor retrieves multiple fixes, this merges those to one.
|
||||
* @param {MessageDescriptor} descriptor The report descriptor.
|
||||
* @param {SourceCode} sourceCode The source code object to get text between fixes.
|
||||
* @returns {({text: string, range: number[]}|null)} The fix for the descriptor
|
||||
*/
|
||||
function normalizeFixes(descriptor, sourceCode) {
|
||||
if (typeof descriptor.fix !== "function") {
|
||||
return null;
|
||||
}
|
||||
|
||||
const ruleFixer = new RuleFixer({ sourceCode });
|
||||
|
||||
// @type {null | Fix | Fix[] | IterableIterator<Fix>}
|
||||
const fix = descriptor.fix(ruleFixer);
|
||||
|
||||
// Merge to one.
|
||||
if (fix && Symbol.iterator in fix) {
|
||||
return mergeFixes(Array.from(fix), sourceCode);
|
||||
}
|
||||
|
||||
assertValidFix(fix);
|
||||
return cloneFix(fix);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets an array of suggestion objects from the given descriptor.
|
||||
* @param {MessageDescriptor} descriptor The report descriptor.
|
||||
* @param {SourceCode} sourceCode The source code object to get text between fixes.
|
||||
* @param {Object} messages Object of meta messages for the rule.
|
||||
* @returns {Array<SuggestionResult>} The suggestions for the descriptor
|
||||
*/
|
||||
function mapSuggestions(descriptor, sourceCode, messages) {
|
||||
if (!descriptor.suggest || !Array.isArray(descriptor.suggest)) {
|
||||
return [];
|
||||
}
|
||||
|
||||
return (
|
||||
descriptor.suggest
|
||||
.map(suggestInfo => {
|
||||
const computedDesc =
|
||||
suggestInfo.desc || messages[suggestInfo.messageId];
|
||||
|
||||
return {
|
||||
...suggestInfo,
|
||||
desc: interpolate(computedDesc, suggestInfo.data),
|
||||
fix: normalizeFixes(suggestInfo, sourceCode),
|
||||
};
|
||||
})
|
||||
|
||||
// Remove suggestions that didn't provide a fix
|
||||
.filter(({ fix }) => fix)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates information about the report from a descriptor
|
||||
* @param {Object} options Information about the problem
|
||||
* @param {string} options.ruleId Rule ID
|
||||
* @param {(0|1|2)} options.severity Rule severity
|
||||
* @param {(ASTNode|null)} options.node Node
|
||||
* @param {string} options.message Error message
|
||||
* @param {string} [options.messageId] The error message ID.
|
||||
* @param {{start: SourceLocation, end: (SourceLocation|null)}} options.loc Start and end location
|
||||
* @param {{text: string, range: (number[]|null)}} options.fix The fix object
|
||||
* @param {Array<{text: string, range: (number[]|null)}>} options.suggestions The array of suggestions objects
|
||||
* @param {Language} [options.language] The language to use to adjust line and column offsets.
|
||||
* @returns {LintMessage} Information about the report
|
||||
*/
|
||||
function createProblem(options) {
|
||||
const { language } = options;
|
||||
|
||||
// calculate offsets based on the language in use
|
||||
const columnOffset = language.columnStart === 1 ? 0 : 1;
|
||||
const lineOffset = language.lineStart === 1 ? 0 : 1;
|
||||
|
||||
const problem = {
|
||||
ruleId: options.ruleId,
|
||||
severity: options.severity,
|
||||
message: options.message,
|
||||
line: options.loc.start.line + lineOffset,
|
||||
column: options.loc.start.column + columnOffset,
|
||||
nodeType: (options.node && options.node.type) || null,
|
||||
};
|
||||
|
||||
/*
|
||||
* If this isn’t in the conditional, some of the tests fail
|
||||
* because `messageId` is present in the problem object
|
||||
*/
|
||||
if (options.messageId) {
|
||||
problem.messageId = options.messageId;
|
||||
}
|
||||
|
||||
if (options.loc.end) {
|
||||
problem.endLine = options.loc.end.line + lineOffset;
|
||||
problem.endColumn = options.loc.end.column + columnOffset;
|
||||
}
|
||||
|
||||
if (options.fix) {
|
||||
problem.fix = options.fix;
|
||||
}
|
||||
|
||||
if (options.suggestions && options.suggestions.length > 0) {
|
||||
problem.suggestions = options.suggestions;
|
||||
}
|
||||
|
||||
return problem;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validates that suggestions are properly defined. Throws if an error is detected.
|
||||
* @param {Array<{ desc?: string, messageId?: string }>} suggest The incoming suggest data.
|
||||
* @param {Object} messages Object of meta messages for the rule.
|
||||
* @returns {void}
|
||||
*/
|
||||
function validateSuggestions(suggest, messages) {
|
||||
if (suggest && Array.isArray(suggest)) {
|
||||
suggest.forEach(suggestion => {
|
||||
if (suggestion.messageId) {
|
||||
const { messageId } = suggestion;
|
||||
|
||||
if (!messages) {
|
||||
throw new TypeError(
|
||||
`context.report() called with a suggest option with a messageId '${messageId}', but no messages were present in the rule metadata.`,
|
||||
);
|
||||
}
|
||||
|
||||
if (!messages[messageId]) {
|
||||
throw new TypeError(
|
||||
`context.report() called with a suggest option with a messageId '${messageId}' which is not present in the 'messages' config: ${JSON.stringify(messages, null, 2)}`,
|
||||
);
|
||||
}
|
||||
|
||||
if (suggestion.desc) {
|
||||
throw new TypeError(
|
||||
"context.report() called with a suggest option that defines both a 'messageId' and an 'desc'. Please only pass one.",
|
||||
);
|
||||
}
|
||||
} else if (!suggestion.desc) {
|
||||
throw new TypeError(
|
||||
"context.report() called with a suggest option that doesn't have either a `desc` or `messageId`",
|
||||
);
|
||||
}
|
||||
|
||||
if (typeof suggestion.fix !== "function") {
|
||||
throw new TypeError(
|
||||
`context.report() called with a suggest option without a fix function. See: ${suggestion}`,
|
||||
);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a function that converts the arguments of a `context.report` call from a rule into a reported
|
||||
* problem for the Node.js API.
|
||||
* @param {{ruleId: string, severity: number, sourceCode: SourceCode, messageIds: Object, disableFixes: boolean, language:Language}} metadata Metadata for the reported problem
|
||||
* @returns {function(...args): LintMessage} Function that returns information about the report
|
||||
*/
|
||||
|
||||
module.exports = function createReportTranslator(metadata) {
|
||||
/*
|
||||
* `createReportTranslator` gets called once per enabled rule per file. It needs to be very performant.
|
||||
* The report translator itself (i.e. the function that `createReportTranslator` returns) gets
|
||||
* called every time a rule reports a problem, which happens much less frequently (usually, the vast
|
||||
* majority of rules don't report any problems for a given file).
|
||||
*/
|
||||
return (...args) => {
|
||||
const descriptor = normalizeMultiArgReportCall(...args);
|
||||
const messages = metadata.messageIds;
|
||||
const { sourceCode } = metadata;
|
||||
|
||||
assertValidNodeInfo(descriptor);
|
||||
|
||||
let computedMessage;
|
||||
|
||||
if (descriptor.messageId) {
|
||||
if (!messages) {
|
||||
throw new TypeError(
|
||||
"context.report() called with a messageId, but no messages were present in the rule metadata.",
|
||||
);
|
||||
}
|
||||
const id = descriptor.messageId;
|
||||
|
||||
if (descriptor.message) {
|
||||
throw new TypeError(
|
||||
"context.report() called with a message and a messageId. Please only pass one.",
|
||||
);
|
||||
}
|
||||
if (!messages || !Object.hasOwn(messages, id)) {
|
||||
throw new TypeError(
|
||||
`context.report() called with a messageId of '${id}' which is not present in the 'messages' config: ${JSON.stringify(messages, null, 2)}`,
|
||||
);
|
||||
}
|
||||
computedMessage = messages[id];
|
||||
} else if (descriptor.message) {
|
||||
computedMessage = descriptor.message;
|
||||
} else {
|
||||
throw new TypeError(
|
||||
"Missing `message` property in report() call; add a message that describes the linting problem.",
|
||||
);
|
||||
}
|
||||
|
||||
validateSuggestions(descriptor.suggest, messages);
|
||||
|
||||
return createProblem({
|
||||
ruleId: metadata.ruleId,
|
||||
severity: metadata.severity,
|
||||
node: descriptor.node,
|
||||
message: interpolate(computedMessage, descriptor.data),
|
||||
messageId: descriptor.messageId,
|
||||
loc: descriptor.loc
|
||||
? normalizeReportLoc(descriptor)
|
||||
: sourceCode.getLoc(descriptor.node),
|
||||
fix: metadata.disableFixes
|
||||
? null
|
||||
: normalizeFixes(descriptor, sourceCode),
|
||||
suggestions: metadata.disableFixes
|
||||
? []
|
||||
: mapSuggestions(descriptor, sourceCode, messages),
|
||||
language: metadata.language,
|
||||
});
|
||||
};
|
||||
};
|
||||
@@ -0,0 +1,290 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.ROOT_CONFIG_FILENAMES = void 0;
|
||||
exports.findConfigUpwards = findConfigUpwards;
|
||||
exports.findRelativeConfig = findRelativeConfig;
|
||||
exports.findRootConfig = findRootConfig;
|
||||
exports.loadConfig = loadConfig;
|
||||
exports.resolveShowConfigPath = resolveShowConfigPath;
|
||||
function _debug() {
|
||||
const data = require("debug");
|
||||
_debug = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _fs() {
|
||||
const data = require("fs");
|
||||
_fs = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _path() {
|
||||
const data = require("path");
|
||||
_path = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _json() {
|
||||
const data = require("json5");
|
||||
_json = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _gensync() {
|
||||
const data = require("gensync");
|
||||
_gensync = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
var _caching = require("../caching.js");
|
||||
var _configApi = require("../helpers/config-api.js");
|
||||
var _utils = require("./utils.js");
|
||||
var _moduleTypes = require("./module-types.js");
|
||||
var _patternToRegex = require("../pattern-to-regex.js");
|
||||
var _configError = require("../../errors/config-error.js");
|
||||
var fs = require("../../gensync-utils/fs.js");
|
||||
require("module");
|
||||
var _rewriteStackTrace = require("../../errors/rewrite-stack-trace.js");
|
||||
var _async = require("../../gensync-utils/async.js");
|
||||
const debug = _debug()("babel:config:loading:files:configuration");
|
||||
const ROOT_CONFIG_FILENAMES = exports.ROOT_CONFIG_FILENAMES = ["babel.config.js", "babel.config.cjs", "babel.config.mjs", "babel.config.json", "babel.config.cts"];
|
||||
const RELATIVE_CONFIG_FILENAMES = [".babelrc", ".babelrc.js", ".babelrc.cjs", ".babelrc.mjs", ".babelrc.json", ".babelrc.cts"];
|
||||
const BABELIGNORE_FILENAME = ".babelignore";
|
||||
const runConfig = (0, _caching.makeWeakCache)(function* runConfig(options, cache) {
|
||||
yield* [];
|
||||
return {
|
||||
options: (0, _rewriteStackTrace.endHiddenCallStack)(options)((0, _configApi.makeConfigAPI)(cache)),
|
||||
cacheNeedsConfiguration: !cache.configured()
|
||||
};
|
||||
});
|
||||
function* readConfigCode(filepath, data) {
|
||||
if (!_fs().existsSync(filepath)) return null;
|
||||
let options = yield* (0, _moduleTypes.default)(filepath, (yield* (0, _async.isAsync)()) ? "auto" : "require", "You appear to be using a native ECMAScript module configuration " + "file, which is only supported when running Babel asynchronously " + "or when using the Node.js `--experimental-require-module` flag.", "You appear to be using a configuration file that contains top-level " + "await, which is only supported when running Babel asynchronously.");
|
||||
let cacheNeedsConfiguration = false;
|
||||
if (typeof options === "function") {
|
||||
({
|
||||
options,
|
||||
cacheNeedsConfiguration
|
||||
} = yield* runConfig(options, data));
|
||||
}
|
||||
if (!options || typeof options !== "object" || Array.isArray(options)) {
|
||||
throw new _configError.default(`Configuration should be an exported JavaScript object.`, filepath);
|
||||
}
|
||||
if (typeof options.then === "function") {
|
||||
options.catch == null || options.catch(() => {});
|
||||
throw new _configError.default(`You appear to be using an async configuration, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously return your config.`, filepath);
|
||||
}
|
||||
if (cacheNeedsConfiguration) throwConfigError(filepath);
|
||||
return buildConfigFileObject(options, filepath);
|
||||
}
|
||||
const cfboaf = new WeakMap();
|
||||
function buildConfigFileObject(options, filepath) {
|
||||
let configFilesByFilepath = cfboaf.get(options);
|
||||
if (!configFilesByFilepath) {
|
||||
cfboaf.set(options, configFilesByFilepath = new Map());
|
||||
}
|
||||
let configFile = configFilesByFilepath.get(filepath);
|
||||
if (!configFile) {
|
||||
configFile = {
|
||||
filepath,
|
||||
dirname: _path().dirname(filepath),
|
||||
options
|
||||
};
|
||||
configFilesByFilepath.set(filepath, configFile);
|
||||
}
|
||||
return configFile;
|
||||
}
|
||||
const packageToBabelConfig = (0, _caching.makeWeakCacheSync)(file => {
|
||||
const babel = file.options["babel"];
|
||||
if (babel === undefined) return null;
|
||||
if (typeof babel !== "object" || Array.isArray(babel) || babel === null) {
|
||||
throw new _configError.default(`.babel property must be an object`, file.filepath);
|
||||
}
|
||||
return {
|
||||
filepath: file.filepath,
|
||||
dirname: file.dirname,
|
||||
options: babel
|
||||
};
|
||||
});
|
||||
const readConfigJSON5 = (0, _utils.makeStaticFileCache)((filepath, content) => {
|
||||
let options;
|
||||
try {
|
||||
options = _json().parse(content);
|
||||
} catch (err) {
|
||||
throw new _configError.default(`Error while parsing config - ${err.message}`, filepath);
|
||||
}
|
||||
if (!options) throw new _configError.default(`No config detected`, filepath);
|
||||
if (typeof options !== "object") {
|
||||
throw new _configError.default(`Config returned typeof ${typeof options}`, filepath);
|
||||
}
|
||||
if (Array.isArray(options)) {
|
||||
throw new _configError.default(`Expected config object but found array`, filepath);
|
||||
}
|
||||
delete options["$schema"];
|
||||
return {
|
||||
filepath,
|
||||
dirname: _path().dirname(filepath),
|
||||
options
|
||||
};
|
||||
});
|
||||
const readIgnoreConfig = (0, _utils.makeStaticFileCache)((filepath, content) => {
|
||||
const ignoreDir = _path().dirname(filepath);
|
||||
const ignorePatterns = content.split("\n").map(line => line.replace(/#.*$/, "").trim()).filter(Boolean);
|
||||
for (const pattern of ignorePatterns) {
|
||||
if (pattern[0] === "!") {
|
||||
throw new _configError.default(`Negation of file paths is not supported.`, filepath);
|
||||
}
|
||||
}
|
||||
return {
|
||||
filepath,
|
||||
dirname: _path().dirname(filepath),
|
||||
ignore: ignorePatterns.map(pattern => (0, _patternToRegex.default)(pattern, ignoreDir))
|
||||
};
|
||||
});
|
||||
function findConfigUpwards(rootDir) {
|
||||
let dirname = rootDir;
|
||||
for (;;) {
|
||||
for (const filename of ROOT_CONFIG_FILENAMES) {
|
||||
if (_fs().existsSync(_path().join(dirname, filename))) {
|
||||
return dirname;
|
||||
}
|
||||
}
|
||||
const nextDir = _path().dirname(dirname);
|
||||
if (dirname === nextDir) break;
|
||||
dirname = nextDir;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function* findRelativeConfig(packageData, envName, caller) {
|
||||
let config = null;
|
||||
let ignore = null;
|
||||
const dirname = _path().dirname(packageData.filepath);
|
||||
for (const loc of packageData.directories) {
|
||||
if (!config) {
|
||||
var _packageData$pkg;
|
||||
config = yield* loadOneConfig(RELATIVE_CONFIG_FILENAMES, loc, envName, caller, ((_packageData$pkg = packageData.pkg) == null ? void 0 : _packageData$pkg.dirname) === loc ? packageToBabelConfig(packageData.pkg) : null);
|
||||
}
|
||||
if (!ignore) {
|
||||
const ignoreLoc = _path().join(loc, BABELIGNORE_FILENAME);
|
||||
ignore = yield* readIgnoreConfig(ignoreLoc);
|
||||
if (ignore) {
|
||||
debug("Found ignore %o from %o.", ignore.filepath, dirname);
|
||||
}
|
||||
}
|
||||
}
|
||||
return {
|
||||
config,
|
||||
ignore
|
||||
};
|
||||
}
|
||||
function findRootConfig(dirname, envName, caller) {
|
||||
return loadOneConfig(ROOT_CONFIG_FILENAMES, dirname, envName, caller);
|
||||
}
|
||||
function* loadOneConfig(names, dirname, envName, caller, previousConfig = null) {
|
||||
const configs = yield* _gensync().all(names.map(filename => readConfig(_path().join(dirname, filename), envName, caller)));
|
||||
const config = configs.reduce((previousConfig, config) => {
|
||||
if (config && previousConfig) {
|
||||
throw new _configError.default(`Multiple configuration files found. Please remove one:\n` + ` - ${_path().basename(previousConfig.filepath)}\n` + ` - ${config.filepath}\n` + `from ${dirname}`);
|
||||
}
|
||||
return config || previousConfig;
|
||||
}, previousConfig);
|
||||
if (config) {
|
||||
debug("Found configuration %o from %o.", config.filepath, dirname);
|
||||
}
|
||||
return config;
|
||||
}
|
||||
function* loadConfig(name, dirname, envName, caller) {
|
||||
const filepath = (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {
|
||||
paths: [b]
|
||||
}, M = require("module")) => {
|
||||
let f = M._findPath(r, M._nodeModulePaths(b).concat(b));
|
||||
if (f) return f;
|
||||
f = new Error(`Cannot resolve module '${r}'`);
|
||||
f.code = "MODULE_NOT_FOUND";
|
||||
throw f;
|
||||
})(name, {
|
||||
paths: [dirname]
|
||||
});
|
||||
const conf = yield* readConfig(filepath, envName, caller);
|
||||
if (!conf) {
|
||||
throw new _configError.default(`Config file contains no configuration data`, filepath);
|
||||
}
|
||||
debug("Loaded config %o from %o.", name, dirname);
|
||||
return conf;
|
||||
}
|
||||
function readConfig(filepath, envName, caller) {
|
||||
const ext = _path().extname(filepath);
|
||||
switch (ext) {
|
||||
case ".js":
|
||||
case ".cjs":
|
||||
case ".mjs":
|
||||
case ".ts":
|
||||
case ".cts":
|
||||
case ".mts":
|
||||
return readConfigCode(filepath, {
|
||||
envName,
|
||||
caller
|
||||
});
|
||||
default:
|
||||
return readConfigJSON5(filepath);
|
||||
}
|
||||
}
|
||||
function* resolveShowConfigPath(dirname) {
|
||||
const targetPath = process.env.BABEL_SHOW_CONFIG_FOR;
|
||||
if (targetPath != null) {
|
||||
const absolutePath = _path().resolve(dirname, targetPath);
|
||||
const stats = yield* fs.stat(absolutePath);
|
||||
if (!stats.isFile()) {
|
||||
throw new Error(`${absolutePath}: BABEL_SHOW_CONFIG_FOR must refer to a regular file, directories are not supported.`);
|
||||
}
|
||||
return absolutePath;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function throwConfigError(filepath) {
|
||||
throw new _configError.default(`\
|
||||
Caching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured
|
||||
for various types of caching, using the first param of their handler functions:
|
||||
|
||||
module.exports = function(api) {
|
||||
// The API exposes the following:
|
||||
|
||||
// Cache the returned value forever and don't call this function again.
|
||||
api.cache(true);
|
||||
|
||||
// Don't cache at all. Not recommended because it will be very slow.
|
||||
api.cache(false);
|
||||
|
||||
// Cached based on the value of some function. If this function returns a value different from
|
||||
// a previously-encountered value, the plugins will re-evaluate.
|
||||
var env = api.cache(() => process.env.NODE_ENV);
|
||||
|
||||
// If testing for a specific env, we recommend specifics to avoid instantiating a plugin for
|
||||
// any possible NODE_ENV value that might come up during plugin execution.
|
||||
var isProd = api.cache(() => process.env.NODE_ENV === "production");
|
||||
|
||||
// .cache(fn) will perform a linear search though instances to find the matching plugin based
|
||||
// based on previous instantiated plugins. If you want to recreate the plugin and discard the
|
||||
// previous instance whenever something changes, you may use:
|
||||
var isProd = api.cache.invalidate(() => process.env.NODE_ENV === "production");
|
||||
|
||||
// Note, we also expose the following more-verbose versions of the above examples:
|
||||
api.cache.forever(); // api.cache(true)
|
||||
api.cache.never(); // api.cache(false)
|
||||
api.cache.using(fn); // api.cache(fn)
|
||||
|
||||
// Return the value that will be cached.
|
||||
return { };
|
||||
};`, filepath);
|
||||
}
|
||||
0 && 0;
|
||||
|
||||
//# sourceMappingURL=configuration.js.map
|
||||
@@ -0,0 +1,38 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = _asyncToGenerator;
|
||||
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
|
||||
try {
|
||||
var info = gen[key](arg);
|
||||
var value = info.value;
|
||||
} catch (error) {
|
||||
reject(error);
|
||||
return;
|
||||
}
|
||||
if (info.done) {
|
||||
resolve(value);
|
||||
} else {
|
||||
Promise.resolve(value).then(_next, _throw);
|
||||
}
|
||||
}
|
||||
function _asyncToGenerator(fn) {
|
||||
return function () {
|
||||
var self = this,
|
||||
args = arguments;
|
||||
return new Promise(function (resolve, reject) {
|
||||
var gen = fn.apply(self, args);
|
||||
function _next(value) {
|
||||
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
|
||||
}
|
||||
function _throw(err) {
|
||||
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
|
||||
}
|
||||
_next(undefined);
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=asyncToGenerator.js.map
|
||||
@@ -0,0 +1,15 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = _isNativeFunction;
|
||||
function _isNativeFunction(fn) {
|
||||
try {
|
||||
return Function.toString.call(fn).indexOf("[native code]") !== -1;
|
||||
} catch (_e) {
|
||||
return typeof fn === "function";
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=isNativeFunction.js.map
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,45 @@
|
||||
/**
|
||||
* @fileoverview Rule to flag usage of __proto__ property
|
||||
* @author Ilya Volodin
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const { getStaticPropertyName } = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description: "Disallow the use of the `__proto__` property",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-proto",
|
||||
},
|
||||
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
unexpectedProto: "The '__proto__' property is deprecated.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
return {
|
||||
MemberExpression(node) {
|
||||
if (getStaticPropertyName(node) === "__proto__") {
|
||||
context.report({ node, messageId: "unexpectedProto" });
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,19 @@
|
||||
Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
@@ -0,0 +1,841 @@
|
||||
import { a as RouteModules, b as Router, D as DataStrategyFunction, c as RouteManifest, S as ServerRouteModule, u as unstable_RouterContextProvider, L as LoaderFunctionArgs, A as ActionFunctionArgs, T as To, d as RelativeRoutingType, e as Location, f as Action, P as ParamParseKey, g as Path, h as PathPattern, i as PathMatch, N as NavigateOptions, j as Params$1, k as RouteObject, l as Navigation, m as RevalidationState, U as UIMatch, n as SerializeFrom, B as BlockerFunction, o as Blocker, p as StaticHandlerContext, q as StaticHandler, F as FutureConfig$1, C as CreateStaticHandlerOptions$1, I as InitialEntry, H as HydrationState, r as unstable_InitialContext, s as IndexRouteObject, t as LoaderFunction, v as ActionFunction, M as MetaFunction, w as LinksFunction, x as NonIndexRouteObject, E as Equal, y as RouterState } from './route-data-5OzAzQtT.mjs';
|
||||
export { au as ClientActionFunction, av as ClientActionFunctionArgs, aw as ClientLoaderFunction, ax as ClientLoaderFunctionArgs, ao as DataRouteMatch, ap as DataRouteObject, W as DataStrategyFunctionArgs, X as DataStrategyMatch, Y as DataStrategyResult, _ as ErrorResponse, J as Fetcher, $ as FormEncType, a0 as FormMethod, G as GetScrollPositionFunction, z as GetScrollRestorationKeyFunction, a1 as HTMLFormMethod, ay as HeadersArgs, az as HeadersFunction, aD as HtmlLinkDescriptor, ae as IDLE_BLOCKER, ad as IDLE_FETCHER, ac as IDLE_NAVIGATION, a2 as LazyRouteFunction, aE as LinkDescriptor, aA as MetaArgs, aB as MetaDescriptor, K as NavigationStates, aq as Navigator, aC as PageLinkDescriptor, ar as PatchRoutesOnNavigationFunction, as as PatchRoutesOnNavigationFunctionArgs, a4 as PathParam, a5 as RedirectFunction, at as RouteMatch, V as RouterFetchOptions, R as RouterInit, Q as RouterNavigateOptions, O as RouterSubscriber, a7 as ShouldRevalidateFunction, a8 as ShouldRevalidateFunctionArgs, aK as UNSAFE_DataRouterContext, aL as UNSAFE_DataRouterStateContext, Z as UNSAFE_DataWithResponseInit, aJ as UNSAFE_ErrorResponseImpl, aM as UNSAFE_FetchersContext, aN as UNSAFE_LocationContext, aO as UNSAFE_NavigationContext, aP as UNSAFE_RouteContext, aQ as UNSAFE_ViewTransitionContext, aG as UNSAFE_createBrowserHistory, aI as UNSAFE_createRouter, aH as UNSAFE_invariant, aa as createPath, af as data, ag as generatePath, ah as isRouteErrorResponse, ai as matchPath, aj as matchRoutes, ab as parsePath, ak as redirect, al as redirectDocument, am as replace, an as resolvePath, a3 as unstable_MiddlewareFunction, a6 as unstable_RouterContext, aF as unstable_SerializesTo, a9 as unstable_createContext } from './route-data-5OzAzQtT.mjs';
|
||||
import { A as AssetsManifest, a as Route, F as FutureConfig, E as EntryContext, C as CriticalCss } from './fog-of-war-1hWhK5ey.mjs';
|
||||
export { g as Await, b as AwaitProps, T as BrowserRouter, B as BrowserRouterProps, D as DOMRouterOpts, w as FetcherFormProps, G as FetcherSubmitFunction, a7 as FetcherSubmitOptions, J as FetcherWithComponents, Y as Form, x as FormProps, U as HashRouter, H as HashRouterProps, s as HistoryRouterProps, I as IndexRouteProps, L as LayoutRouteProps, V as Link, t as LinkProps, ae as Links, h as MemoryRouter, M as MemoryRouterOpts, c as MemoryRouterProps, ad as Meta, X as NavLink, u as NavLinkProps, v as NavLinkRenderProps, i as Navigate, N as NavigateProps, j as Outlet, O as OutletProps, a8 as ParamKeyValuePair, P as PathRouteProps, ag as PrefetchPageLinks, k as Route, d as RouteProps, l as Router, e as RouterProps, m as RouterProvider, R as RouterProviderProps, n as Routes, f as RoutesProps, af as Scripts, ah as ScriptsProps, Z as ScrollRestoration, S as ScrollRestorationProps, y as SetURLSearchParams, z as SubmitFunction, a9 as SubmitOptions, ab as SubmitTarget, aj as UNSAFE_FrameworkContext, am as UNSAFE_createClientRoutes, an as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, ak as UNSAFE_getPatchRoutesOnNavigationFunction, ai as UNSAFE_mapRouteProperties, ao as UNSAFE_shouldHydrateRouteLoader, al as UNSAFE_useFogOFWarDiscovery, ap as UNSAFE_useScrollRestoration, aa as URLSearchParamsInit, K as createBrowserRouter, Q as createHashRouter, o as createMemoryRouter, p as createRoutesFromChildren, q as createRoutesFromElements, ac as createSearchParams, r as renderMatches, W as unstable_HistoryRouter, a5 as unstable_usePrompt, a4 as useBeforeUnload, a2 as useFetcher, a3 as useFetchers, a1 as useFormAction, _ as useLinkClickHandler, $ as useSearchParams, a0 as useSubmit, a6 as useViewTransitionState } from './fog-of-war-1hWhK5ey.mjs';
|
||||
import * as React from 'react';
|
||||
import { ReactElement } from 'react';
|
||||
import { ParseOptions, SerializeOptions } from 'cookie';
|
||||
export { ParseOptions as CookieParseOptions, SerializeOptions as CookieSerializeOptions } from 'cookie';
|
||||
import { M as MiddlewareEnabled, A as AppLoadContext } from './future-ldDp5FKH.mjs';
|
||||
export { F as Future } from './future-ldDp5FKH.mjs';
|
||||
|
||||
declare const SingleFetchRedirectSymbol: unique symbol;
|
||||
declare function getSingleFetchDataStrategy(manifest: AssetsManifest, routeModules: RouteModules, ssr: boolean, basename: string | undefined, getRouter: () => Router): DataStrategyFunction;
|
||||
declare function decodeViaTurboStream(body: ReadableStream<Uint8Array>, global: Window | typeof globalThis): Promise<{
|
||||
done: Promise<undefined>;
|
||||
value: unknown;
|
||||
}>;
|
||||
|
||||
/**
|
||||
* The mode to use when running the server.
|
||||
*/
|
||||
declare enum ServerMode {
|
||||
Development = "development",
|
||||
Production = "production",
|
||||
Test = "test"
|
||||
}
|
||||
|
||||
type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
|
||||
interface ServerRoute extends Route {
|
||||
children: ServerRoute[];
|
||||
module: ServerRouteModule;
|
||||
}
|
||||
|
||||
type OptionalCriticalCss = CriticalCss | undefined;
|
||||
/**
|
||||
* The output of the compiler for the server build.
|
||||
*/
|
||||
interface ServerBuild {
|
||||
entry: {
|
||||
module: ServerEntryModule;
|
||||
};
|
||||
routes: ServerRouteManifest;
|
||||
assets: AssetsManifest;
|
||||
basename?: string;
|
||||
publicPath: string;
|
||||
assetsBuildDirectory: string;
|
||||
future: FutureConfig;
|
||||
ssr: boolean;
|
||||
unstable_getCriticalCss?: (args: {
|
||||
pathname: string;
|
||||
}) => OptionalCriticalCss | Promise<OptionalCriticalCss>;
|
||||
/**
|
||||
* @deprecated This is now done via a custom header during prerendering
|
||||
*/
|
||||
isSpaMode: boolean;
|
||||
prerender: string[];
|
||||
}
|
||||
interface HandleDocumentRequestFunction {
|
||||
(request: Request, responseStatusCode: number, responseHeaders: Headers, context: EntryContext, loadContext: MiddlewareEnabled extends true ? unstable_RouterContextProvider : AppLoadContext): Promise<Response> | Response;
|
||||
}
|
||||
interface HandleDataRequestFunction {
|
||||
(response: Response, args: LoaderFunctionArgs | ActionFunctionArgs): Promise<Response> | Response;
|
||||
}
|
||||
interface HandleErrorFunction {
|
||||
(error: unknown, args: LoaderFunctionArgs | ActionFunctionArgs): void;
|
||||
}
|
||||
/**
|
||||
* A module that serves as the entry point for a Remix app during server
|
||||
* rendering.
|
||||
*/
|
||||
interface ServerEntryModule {
|
||||
default: HandleDocumentRequestFunction;
|
||||
handleDataRequest?: HandleDataRequestFunction;
|
||||
handleError?: HandleErrorFunction;
|
||||
streamTimeout?: number;
|
||||
}
|
||||
|
||||
/**
|
||||
Resolves a URL against the current location.
|
||||
|
||||
```tsx
|
||||
import { useHref } from "react-router"
|
||||
|
||||
function SomeComponent() {
|
||||
let href = useHref("some/where");
|
||||
// "/resolved/some/where"
|
||||
}
|
||||
```
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useHref(to: To, { relative }?: {
|
||||
relative?: RelativeRoutingType;
|
||||
}): string;
|
||||
/**
|
||||
* Returns true if this component is a descendant of a Router, useful to ensure
|
||||
* a component is used within a Router.
|
||||
*
|
||||
* @category Hooks
|
||||
*/
|
||||
declare function useInRouterContext(): boolean;
|
||||
/**
|
||||
Returns the current {@link Location}. This can be useful if you'd like to perform some side effect whenever it changes.
|
||||
|
||||
```tsx
|
||||
import * as React from 'react'
|
||||
import { useLocation } from 'react-router'
|
||||
|
||||
function SomeComponent() {
|
||||
let location = useLocation()
|
||||
|
||||
React.useEffect(() => {
|
||||
// Google Analytics
|
||||
ga('send', 'pageview')
|
||||
}, [location]);
|
||||
|
||||
return (
|
||||
// ...
|
||||
);
|
||||
}
|
||||
```
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useLocation(): Location;
|
||||
/**
|
||||
* Returns the current navigation action which describes how the router came to
|
||||
* the current location, either by a pop, push, or replace on the history stack.
|
||||
*
|
||||
* @category Hooks
|
||||
*/
|
||||
declare function useNavigationType(): Action;
|
||||
/**
|
||||
* Returns a PathMatch object if the given pattern matches the current URL.
|
||||
* This is useful for components that need to know "active" state, e.g.
|
||||
* `<NavLink>`.
|
||||
*
|
||||
* @category Hooks
|
||||
*/
|
||||
declare function useMatch<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null;
|
||||
/**
|
||||
* The interface for the navigate() function returned from useNavigate().
|
||||
*/
|
||||
interface NavigateFunction {
|
||||
(to: To, options?: NavigateOptions): void | Promise<void>;
|
||||
(delta: number): void | Promise<void>;
|
||||
}
|
||||
/**
|
||||
Returns a function that lets you navigate programmatically in the browser in response to user interactions or effects.
|
||||
|
||||
```tsx
|
||||
import { useNavigate } from "react-router";
|
||||
|
||||
function SomeComponent() {
|
||||
let navigate = useNavigate();
|
||||
return (
|
||||
<button
|
||||
onClick={() => {
|
||||
navigate(-1);
|
||||
}}
|
||||
/>
|
||||
);
|
||||
}
|
||||
```
|
||||
|
||||
It's often better to use {@link redirect} in {@link ActionFunction | actions} and {@link LoaderFunction | loaders} than this hook.
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useNavigate(): NavigateFunction;
|
||||
/**
|
||||
* Returns the parent route {@link OutletProps.context | `<Outlet context>`}.
|
||||
*
|
||||
* @category Hooks
|
||||
*/
|
||||
declare function useOutletContext<Context = unknown>(): Context;
|
||||
/**
|
||||
* Returns the element for the child route at this level of the route
|
||||
* hierarchy. Used internally by `<Outlet>` to render child routes.
|
||||
*
|
||||
* @category Hooks
|
||||
*/
|
||||
declare function useOutlet(context?: unknown): React.ReactElement | null;
|
||||
/**
|
||||
Returns an object of key/value pairs of the dynamic params from the current URL that were matched by the routes. Child routes inherit all params from their parent routes.
|
||||
|
||||
```tsx
|
||||
import { useParams } from "react-router"
|
||||
|
||||
function SomeComponent() {
|
||||
let params = useParams()
|
||||
params.postId
|
||||
}
|
||||
```
|
||||
|
||||
Assuming a route pattern like `/posts/:postId` is matched by `/posts/123` then `params.postId` will be `"123"`.
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useParams<ParamsOrKey extends string | Record<string, string | undefined> = string>(): Readonly<[
|
||||
ParamsOrKey
|
||||
] extends [string] ? Params$1<ParamsOrKey> : Partial<ParamsOrKey>>;
|
||||
/**
|
||||
Resolves the pathname of the given `to` value against the current location. Similar to {@link useHref}, but returns a {@link Path} instead of a string.
|
||||
|
||||
```tsx
|
||||
import { useResolvedPath } from "react-router"
|
||||
|
||||
function SomeComponent() {
|
||||
// if the user is at /dashboard/profile
|
||||
let path = useResolvedPath("../accounts")
|
||||
path.pathname // "/dashboard/accounts"
|
||||
path.search // ""
|
||||
path.hash // ""
|
||||
}
|
||||
```
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useResolvedPath(to: To, { relative }?: {
|
||||
relative?: RelativeRoutingType;
|
||||
}): Path;
|
||||
/**
|
||||
Hook version of {@link Routes | `<Routes>`} that uses objects instead of components. These objects have the same properties as the component props.
|
||||
|
||||
The return value of `useRoutes` is either a valid React element you can use to render the route tree, or `null` if nothing matched.
|
||||
|
||||
```tsx
|
||||
import * as React from "react";
|
||||
import { useRoutes } from "react-router";
|
||||
|
||||
function App() {
|
||||
let element = useRoutes([
|
||||
{
|
||||
path: "/",
|
||||
element: <Dashboard />,
|
||||
children: [
|
||||
{
|
||||
path: "messages",
|
||||
element: <DashboardMessages />,
|
||||
},
|
||||
{ path: "tasks", element: <DashboardTasks /> },
|
||||
],
|
||||
},
|
||||
{ path: "team", element: <AboutPage /> },
|
||||
]);
|
||||
|
||||
return element;
|
||||
}
|
||||
```
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useRoutes(routes: RouteObject[], locationArg?: Partial<Location> | string): React.ReactElement | null;
|
||||
/**
|
||||
Returns the current navigation, defaulting to an "idle" navigation when no navigation is in progress. You can use this to render pending UI (like a global spinner) or read FormData from a form navigation.
|
||||
|
||||
```tsx
|
||||
import { useNavigation } from "react-router"
|
||||
|
||||
function SomeComponent() {
|
||||
let navigation = useNavigation();
|
||||
navigation.state
|
||||
navigation.formData
|
||||
// etc.
|
||||
}
|
||||
```
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useNavigation(): Navigation;
|
||||
/**
|
||||
Revalidate the data on the page for reasons outside of normal data mutations like window focus or polling on an interval.
|
||||
|
||||
```tsx
|
||||
import { useRevalidator } from "react-router";
|
||||
|
||||
function WindowFocusRevalidator() {
|
||||
const revalidator = useRevalidator();
|
||||
|
||||
useFakeWindowFocus(() => {
|
||||
revalidator.revalidate();
|
||||
});
|
||||
|
||||
return (
|
||||
<div hidden={revalidator.state === "idle"}>
|
||||
Revalidating...
|
||||
</div>
|
||||
);
|
||||
}
|
||||
```
|
||||
|
||||
Note that page data is already revalidated automatically after actions. If you find yourself using this for normal CRUD operations on your data in response to user interactions, you're probably not taking advantage of the other APIs like {@link useFetcher}, {@link Form}, {@link useSubmit} that do this automatically.
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useRevalidator(): {
|
||||
revalidate(): Promise<void>;
|
||||
state: RevalidationState;
|
||||
};
|
||||
/**
|
||||
* Returns the active route matches, useful for accessing loaderData for
|
||||
* parent/child routes or the route "handle" property
|
||||
*
|
||||
* @category Hooks
|
||||
*/
|
||||
declare function useMatches(): UIMatch[];
|
||||
/**
|
||||
Returns the data from the closest route {@link LoaderFunction | loader} or {@link ClientLoaderFunction | client loader}.
|
||||
|
||||
```tsx
|
||||
import { useLoaderData } from "react-router"
|
||||
|
||||
export async function loader() {
|
||||
return await fakeDb.invoices.findAll();
|
||||
}
|
||||
|
||||
export default function Invoices() {
|
||||
let invoices = useLoaderData<typeof loader>();
|
||||
// ...
|
||||
}
|
||||
```
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useLoaderData<T = any>(): SerializeFrom<T>;
|
||||
/**
|
||||
Returns the loader data for a given route by route ID.
|
||||
|
||||
```tsx
|
||||
import { useRouteLoaderData } from "react-router";
|
||||
|
||||
function SomeComponent() {
|
||||
const { user } = useRouteLoaderData("root");
|
||||
}
|
||||
```
|
||||
|
||||
Route IDs are created automatically. They are simply the path of the route file relative to the app folder without the extension.
|
||||
|
||||
| Route Filename | Route ID |
|
||||
| -------------------------- | -------------------- |
|
||||
| `app/root.tsx` | `"root"` |
|
||||
| `app/routes/teams.tsx` | `"routes/teams"` |
|
||||
| `app/whatever/teams.$id.tsx` | `"whatever/teams.$id"` |
|
||||
|
||||
If you created an ID manually, you can use that instead:
|
||||
|
||||
```tsx
|
||||
route("/", "containers/app.tsx", { id: "app" }})
|
||||
```
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useRouteLoaderData<T = any>(routeId: string): SerializeFrom<T> | undefined;
|
||||
/**
|
||||
Returns the action data from the most recent POST navigation form submission or `undefined` if there hasn't been one.
|
||||
|
||||
```tsx
|
||||
import { Form, useActionData } from "react-router"
|
||||
|
||||
export async function action({ request }) {
|
||||
const body = await request.formData()
|
||||
const name = body.get("visitorsName")
|
||||
return { message: `Hello, ${name}` }
|
||||
}
|
||||
|
||||
export default function Invoices() {
|
||||
const data = useActionData()
|
||||
return (
|
||||
<Form method="post">
|
||||
<input type="text" name="visitorsName" />
|
||||
{data ? data.message : "Waiting..."}
|
||||
</Form>
|
||||
)
|
||||
}
|
||||
```
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useActionData<T = any>(): SerializeFrom<T> | undefined;
|
||||
/**
|
||||
Accesses the error thrown during an {@link ActionFunction | action}, {@link LoaderFunction | loader}, or component render to be used in a route module Error Boundary.
|
||||
|
||||
```tsx
|
||||
export function ErrorBoundary() {
|
||||
const error = useRouteError();
|
||||
return <div>{error.message}</div>;
|
||||
}
|
||||
```
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useRouteError(): unknown;
|
||||
/**
|
||||
Returns the resolved promise value from the closest {@link Await | `<Await>`}.
|
||||
|
||||
```tsx
|
||||
function SomeDescendant() {
|
||||
const value = useAsyncValue();
|
||||
// ...
|
||||
}
|
||||
|
||||
// somewhere in your app
|
||||
<Await resolve={somePromise}>
|
||||
<SomeDescendant />
|
||||
</Await>
|
||||
```
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useAsyncValue(): unknown;
|
||||
/**
|
||||
Returns the rejection value from the closest {@link Await | `<Await>`}.
|
||||
|
||||
```tsx
|
||||
import { Await, useAsyncError } from "react-router"
|
||||
|
||||
function ErrorElement() {
|
||||
const error = useAsyncError();
|
||||
return (
|
||||
<p>Uh Oh, something went wrong! {error.message}</p>
|
||||
);
|
||||
}
|
||||
|
||||
// somewhere in your app
|
||||
<Await
|
||||
resolve={promiseThatRejects}
|
||||
errorElement={<ErrorElement />}
|
||||
/>
|
||||
```
|
||||
|
||||
@category Hooks
|
||||
*/
|
||||
declare function useAsyncError(): unknown;
|
||||
/**
|
||||
* Allow the application to block navigations within the SPA and present the
|
||||
* user a confirmation dialog to confirm the navigation. Mostly used to avoid
|
||||
* using half-filled form data. This does not handle hard-reloads or
|
||||
* cross-origin navigations.
|
||||
*
|
||||
* @category Hooks
|
||||
*/
|
||||
declare function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker;
|
||||
|
||||
interface StaticRouterProps {
|
||||
basename?: string;
|
||||
children?: React.ReactNode;
|
||||
location: Partial<Location> | string;
|
||||
}
|
||||
/**
|
||||
* A `<Router>` that may not navigate to any other location. This is useful
|
||||
* on the server where there is no stateful UI.
|
||||
*
|
||||
* @category Component Routers
|
||||
*/
|
||||
declare function StaticRouter({ basename, children, location: locationProp, }: StaticRouterProps): React.JSX.Element;
|
||||
interface StaticRouterProviderProps {
|
||||
context: StaticHandlerContext;
|
||||
router: Router;
|
||||
hydrate?: boolean;
|
||||
nonce?: string;
|
||||
}
|
||||
/**
|
||||
* A Data Router that may not navigate to any other location. This is useful
|
||||
* on the server where there is no stateful UI.
|
||||
*
|
||||
* @category Component Routers
|
||||
*/
|
||||
declare function StaticRouterProvider({ context, router, hydrate, nonce, }: StaticRouterProviderProps): React.JSX.Element;
|
||||
type CreateStaticHandlerOptions = Omit<CreateStaticHandlerOptions$1, "mapRouteProperties">;
|
||||
/**
|
||||
* @category Utils
|
||||
*/
|
||||
declare function createStaticHandler(routes: RouteObject[], opts?: CreateStaticHandlerOptions): StaticHandler;
|
||||
/**
|
||||
* @category Data Routers
|
||||
*/
|
||||
declare function createStaticRouter(routes: RouteObject[], context: StaticHandlerContext, opts?: {
|
||||
future?: Partial<FutureConfig$1>;
|
||||
}): Router;
|
||||
|
||||
interface ServerRouterProps {
|
||||
context: EntryContext;
|
||||
url: string | URL;
|
||||
nonce?: string;
|
||||
}
|
||||
/**
|
||||
* The entry point for a Remix app when it is rendered on the server (in
|
||||
* `app/entry.server.js`). This component is used to generate the HTML in the
|
||||
* response from the server.
|
||||
*
|
||||
* @category Components
|
||||
*/
|
||||
declare function ServerRouter({ context, url, nonce, }: ServerRouterProps): ReactElement;
|
||||
|
||||
interface StubIndexRouteObject extends Omit<IndexRouteObject, "loader" | "action" | "element" | "errorElement" | "children"> {
|
||||
loader?: LoaderFunction;
|
||||
action?: ActionFunction;
|
||||
children?: StubRouteObject[];
|
||||
meta?: MetaFunction;
|
||||
links?: LinksFunction;
|
||||
}
|
||||
interface StubNonIndexRouteObject extends Omit<NonIndexRouteObject, "loader" | "action" | "element" | "errorElement" | "children"> {
|
||||
loader?: LoaderFunction;
|
||||
action?: ActionFunction;
|
||||
children?: StubRouteObject[];
|
||||
meta?: MetaFunction;
|
||||
links?: LinksFunction;
|
||||
}
|
||||
type StubRouteObject = StubIndexRouteObject | StubNonIndexRouteObject;
|
||||
interface RoutesTestStubProps {
|
||||
/**
|
||||
* The initial entries in the history stack. This allows you to start a test with
|
||||
* multiple locations already in the history stack (for testing a back navigation, etc.)
|
||||
* The test will default to the last entry in initialEntries if no initialIndex is provided.
|
||||
* e.g. initialEntries={["/home", "/about", "/contact"]}
|
||||
*/
|
||||
initialEntries?: InitialEntry[];
|
||||
/**
|
||||
* The initial index in the history stack to render. This allows you to start a test at a specific entry.
|
||||
* It defaults to the last entry in initialEntries.
|
||||
* e.g.
|
||||
* initialEntries: ["/", "/events/123"]
|
||||
* initialIndex: 1 // start at "/events/123"
|
||||
*/
|
||||
initialIndex?: number;
|
||||
/**
|
||||
* Used to set the route's initial loader and action data.
|
||||
* e.g. hydrationData={{
|
||||
* loaderData: { "/contact": { locale: "en-US" } },
|
||||
* actionData: { "/login": { errors: { email: "invalid email" } }}
|
||||
* }}
|
||||
*/
|
||||
hydrationData?: HydrationState;
|
||||
/**
|
||||
* Future flags mimicking the settings in react-router.config.ts
|
||||
*/
|
||||
future?: Partial<FutureConfig>;
|
||||
}
|
||||
/**
|
||||
* @category Utils
|
||||
*/
|
||||
declare function createRoutesStub(routes: StubRouteObject[], unstable_getContext?: () => unstable_InitialContext): ({ initialEntries, initialIndex, hydrationData, future, }: RoutesTestStubProps) => React.JSX.Element;
|
||||
|
||||
interface CookieSignatureOptions {
|
||||
/**
|
||||
* An array of secrets that may be used to sign/unsign the value of a cookie.
|
||||
*
|
||||
* The array makes it easy to rotate secrets. New secrets should be added to
|
||||
* the beginning of the array. `cookie.serialize()` will always use the first
|
||||
* value in the array, but `cookie.parse()` may use any of them so that
|
||||
* cookies that were signed with older secrets still work.
|
||||
*/
|
||||
secrets?: string[];
|
||||
}
|
||||
type CookieOptions = ParseOptions & SerializeOptions & CookieSignatureOptions;
|
||||
/**
|
||||
* A HTTP cookie.
|
||||
*
|
||||
* A Cookie is a logical container for metadata about a HTTP cookie; its name
|
||||
* and options. But it doesn't contain a value. Instead, it has `parse()` and
|
||||
* `serialize()` methods that allow a single instance to be reused for
|
||||
* parsing/encoding multiple different values.
|
||||
*
|
||||
* @see https://remix.run/utils/cookies#cookie-api
|
||||
*/
|
||||
interface Cookie {
|
||||
/**
|
||||
* The name of the cookie, used in the `Cookie` and `Set-Cookie` headers.
|
||||
*/
|
||||
readonly name: string;
|
||||
/**
|
||||
* True if this cookie uses one or more secrets for verification.
|
||||
*/
|
||||
readonly isSigned: boolean;
|
||||
/**
|
||||
* The Date this cookie expires.
|
||||
*
|
||||
* Note: This is calculated at access time using `maxAge` when no `expires`
|
||||
* option is provided to `createCookie()`.
|
||||
*/
|
||||
readonly expires?: Date;
|
||||
/**
|
||||
* Parses a raw `Cookie` header and returns the value of this cookie or
|
||||
* `null` if it's not present.
|
||||
*/
|
||||
parse(cookieHeader: string | null, options?: ParseOptions): Promise<any>;
|
||||
/**
|
||||
* Serializes the given value to a string and returns the `Set-Cookie`
|
||||
* header.
|
||||
*/
|
||||
serialize(value: any, options?: SerializeOptions): Promise<string>;
|
||||
}
|
||||
/**
|
||||
* Creates a logical container for managing a browser cookie from the server.
|
||||
*/
|
||||
declare const createCookie: (name: string, cookieOptions?: CookieOptions) => Cookie;
|
||||
type IsCookieFunction = (object: any) => object is Cookie;
|
||||
/**
|
||||
* Returns true if an object is a Remix cookie container.
|
||||
*
|
||||
* @see https://remix.run/utils/cookies#iscookie
|
||||
*/
|
||||
declare const isCookie: IsCookieFunction;
|
||||
|
||||
type RequestHandler = (request: Request, loadContext?: MiddlewareEnabled extends true ? unstable_InitialContext : AppLoadContext) => Promise<Response>;
|
||||
type CreateRequestHandlerFunction = (build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>), mode?: string) => RequestHandler;
|
||||
declare const createRequestHandler: CreateRequestHandlerFunction;
|
||||
|
||||
/**
|
||||
* An object of name/value pairs to be used in the session.
|
||||
*/
|
||||
interface SessionData {
|
||||
[name: string]: any;
|
||||
}
|
||||
/**
|
||||
* Session persists data across HTTP requests.
|
||||
*
|
||||
* @see https://remix.run/utils/sessions#session-api
|
||||
*/
|
||||
interface Session<Data = SessionData, FlashData = Data> {
|
||||
/**
|
||||
* A unique identifier for this session.
|
||||
*
|
||||
* Note: This will be the empty string for newly created sessions and
|
||||
* sessions that are not backed by a database (i.e. cookie-based sessions).
|
||||
*/
|
||||
readonly id: string;
|
||||
/**
|
||||
* The raw data contained in this session.
|
||||
*
|
||||
* This is useful mostly for SessionStorage internally to access the raw
|
||||
* session data to persist.
|
||||
*/
|
||||
readonly data: FlashSessionData<Data, FlashData>;
|
||||
/**
|
||||
* Returns `true` if the session has a value for the given `name`, `false`
|
||||
* otherwise.
|
||||
*/
|
||||
has(name: (keyof Data | keyof FlashData) & string): boolean;
|
||||
/**
|
||||
* Returns the value for the given `name` in this session.
|
||||
*/
|
||||
get<Key extends (keyof Data | keyof FlashData) & string>(name: Key): (Key extends keyof Data ? Data[Key] : undefined) | (Key extends keyof FlashData ? FlashData[Key] : undefined) | undefined;
|
||||
/**
|
||||
* Sets a value in the session for the given `name`.
|
||||
*/
|
||||
set<Key extends keyof Data & string>(name: Key, value: Data[Key]): void;
|
||||
/**
|
||||
* Sets a value in the session that is only valid until the next `get()`.
|
||||
* This can be useful for temporary values, like error messages.
|
||||
*/
|
||||
flash<Key extends keyof FlashData & string>(name: Key, value: FlashData[Key]): void;
|
||||
/**
|
||||
* Removes a value from the session.
|
||||
*/
|
||||
unset(name: keyof Data & string): void;
|
||||
}
|
||||
type FlashSessionData<Data, FlashData> = Partial<Data & {
|
||||
[Key in keyof FlashData as FlashDataKey<Key & string>]: FlashData[Key];
|
||||
}>;
|
||||
type FlashDataKey<Key extends string> = `__flash_${Key}__`;
|
||||
type CreateSessionFunction = <Data = SessionData, FlashData = Data>(initialData?: Data, id?: string) => Session<Data, FlashData>;
|
||||
/**
|
||||
* Creates a new Session object.
|
||||
*
|
||||
* Note: This function is typically not invoked directly by application code.
|
||||
* Instead, use a `SessionStorage` object's `getSession` method.
|
||||
*
|
||||
* @see https://remix.run/utils/sessions#createsession
|
||||
*/
|
||||
declare const createSession: CreateSessionFunction;
|
||||
type IsSessionFunction = (object: any) => object is Session;
|
||||
/**
|
||||
* Returns true if an object is a Remix session.
|
||||
*
|
||||
* @see https://remix.run/utils/sessions#issession
|
||||
*/
|
||||
declare const isSession: IsSessionFunction;
|
||||
/**
|
||||
* SessionStorage stores session data between HTTP requests and knows how to
|
||||
* parse and create cookies.
|
||||
*
|
||||
* A SessionStorage creates Session objects using a `Cookie` header as input.
|
||||
* Then, later it generates the `Set-Cookie` header to be used in the response.
|
||||
*/
|
||||
interface SessionStorage<Data = SessionData, FlashData = Data> {
|
||||
/**
|
||||
* Parses a Cookie header from a HTTP request and returns the associated
|
||||
* Session. If there is no session associated with the cookie, this will
|
||||
* return a new Session with no data.
|
||||
*/
|
||||
getSession: (cookieHeader?: string | null, options?: ParseOptions) => Promise<Session<Data, FlashData>>;
|
||||
/**
|
||||
* Stores all data in the Session and returns the Set-Cookie header to be
|
||||
* used in the HTTP response.
|
||||
*/
|
||||
commitSession: (session: Session<Data, FlashData>, options?: SerializeOptions) => Promise<string>;
|
||||
/**
|
||||
* Deletes all data associated with the Session and returns the Set-Cookie
|
||||
* header to be used in the HTTP response.
|
||||
*/
|
||||
destroySession: (session: Session<Data, FlashData>, options?: SerializeOptions) => Promise<string>;
|
||||
}
|
||||
/**
|
||||
* SessionIdStorageStrategy is designed to allow anyone to easily build their
|
||||
* own SessionStorage using `createSessionStorage(strategy)`.
|
||||
*
|
||||
* This strategy describes a common scenario where the session id is stored in
|
||||
* a cookie but the actual session data is stored elsewhere, usually in a
|
||||
* database or on disk. A set of create, read, update, and delete operations
|
||||
* are provided for managing the session data.
|
||||
*/
|
||||
interface SessionIdStorageStrategy<Data = SessionData, FlashData = Data> {
|
||||
/**
|
||||
* The Cookie used to store the session id, or options used to automatically
|
||||
* create one.
|
||||
*/
|
||||
cookie?: Cookie | (CookieOptions & {
|
||||
name?: string;
|
||||
});
|
||||
/**
|
||||
* Creates a new record with the given data and returns the session id.
|
||||
*/
|
||||
createData: (data: FlashSessionData<Data, FlashData>, expires?: Date) => Promise<string>;
|
||||
/**
|
||||
* Returns data for a given session id, or `null` if there isn't any.
|
||||
*/
|
||||
readData: (id: string) => Promise<FlashSessionData<Data, FlashData> | null>;
|
||||
/**
|
||||
* Updates data for the given session id.
|
||||
*/
|
||||
updateData: (id: string, data: FlashSessionData<Data, FlashData>, expires?: Date) => Promise<void>;
|
||||
/**
|
||||
* Deletes data for a given session id from the data store.
|
||||
*/
|
||||
deleteData: (id: string) => Promise<void>;
|
||||
}
|
||||
/**
|
||||
* Creates a SessionStorage object using a SessionIdStorageStrategy.
|
||||
*
|
||||
* Note: This is a low-level API that should only be used if none of the
|
||||
* existing session storage options meet your requirements.
|
||||
*/
|
||||
declare function createSessionStorage<Data = SessionData, FlashData = Data>({ cookie: cookieArg, createData, readData, updateData, deleteData, }: SessionIdStorageStrategy<Data, FlashData>): SessionStorage<Data, FlashData>;
|
||||
|
||||
interface CookieSessionStorageOptions {
|
||||
/**
|
||||
* The Cookie used to store the session data on the client, or options used
|
||||
* to automatically create one.
|
||||
*/
|
||||
cookie?: SessionIdStorageStrategy["cookie"];
|
||||
}
|
||||
/**
|
||||
* Creates and returns a SessionStorage object that stores all session data
|
||||
* directly in the session cookie itself.
|
||||
*
|
||||
* This has the advantage that no database or other backend services are
|
||||
* needed, and can help to simplify some load-balanced scenarios. However, it
|
||||
* also has the limitation that serialized session data may not exceed the
|
||||
* browser's maximum cookie size. Trade-offs!
|
||||
*/
|
||||
declare function createCookieSessionStorage<Data = SessionData, FlashData = Data>({ cookie: cookieArg }?: CookieSessionStorageOptions): SessionStorage<Data, FlashData>;
|
||||
|
||||
interface MemorySessionStorageOptions {
|
||||
/**
|
||||
* The Cookie used to store the session id on the client, or options used
|
||||
* to automatically create one.
|
||||
*/
|
||||
cookie?: SessionIdStorageStrategy["cookie"];
|
||||
}
|
||||
/**
|
||||
* Creates and returns a simple in-memory SessionStorage object, mostly useful
|
||||
* for testing and as a reference implementation.
|
||||
*
|
||||
* Note: This storage does not scale beyond a single process, so it is not
|
||||
* suitable for most production scenarios.
|
||||
*/
|
||||
declare function createMemorySessionStorage<Data = SessionData, FlashData = Data>({ cookie }?: MemorySessionStorageOptions): SessionStorage<Data, FlashData>;
|
||||
|
||||
type DevServerHooks = {
|
||||
getCriticalCss?: (pathname: string) => Promise<string | undefined>;
|
||||
processRequestError?: (error: unknown) => void;
|
||||
};
|
||||
declare function setDevServerHooks(devServerHooks: DevServerHooks): void;
|
||||
|
||||
/**
|
||||
* Apps can use this interface to "register" app-wide types for React Router via interface declaration merging and module augmentation.
|
||||
* React Router should handle this for you via type generation.
|
||||
*
|
||||
* For more on declaration merging and module augmentation, see https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation .
|
||||
*/
|
||||
interface Register {
|
||||
}
|
||||
|
||||
type AnyParams = Record<string, Record<string, string | undefined>>;
|
||||
type Params = Register extends {
|
||||
params: infer RegisteredParams extends AnyParams;
|
||||
} ? RegisteredParams : AnyParams;
|
||||
type Args = {
|
||||
[K in keyof Params]: ToArgs<Params[K]>;
|
||||
};
|
||||
type ToArgs<T> = Equal<T, {}> extends true ? [] : Partial<T> extends T ? [T] | [] : [
|
||||
T
|
||||
];
|
||||
/**
|
||||
Returns a resolved URL path for the specified route.
|
||||
|
||||
```tsx
|
||||
const h = href("/:lang?/about", { lang: "en" })
|
||||
// -> `/en/about`
|
||||
|
||||
<Link to={href("/products/:id", { id: "abc123" })} />
|
||||
```
|
||||
*/
|
||||
declare function href<Path extends keyof Args>(path: Path, ...args: Args[Path]): string;
|
||||
|
||||
declare function deserializeErrors(errors: RouterState["errors"]): RouterState["errors"];
|
||||
|
||||
type RemixErrorBoundaryProps = React.PropsWithChildren<{
|
||||
location: Location;
|
||||
isOutsideRemixApp?: boolean;
|
||||
error?: Error;
|
||||
}>;
|
||||
type RemixErrorBoundaryState = {
|
||||
error: null | Error;
|
||||
location: Location;
|
||||
};
|
||||
declare class RemixErrorBoundary extends React.Component<RemixErrorBoundaryProps, RemixErrorBoundaryState> {
|
||||
constructor(props: RemixErrorBoundaryProps);
|
||||
static getDerivedStateFromError(error: Error): {
|
||||
error: Error;
|
||||
};
|
||||
static getDerivedStateFromProps(props: RemixErrorBoundaryProps, state: RemixErrorBoundaryState): {
|
||||
error: Error | null;
|
||||
location: Location<any>;
|
||||
};
|
||||
render(): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
|
||||
}
|
||||
|
||||
export { ActionFunction, ActionFunctionArgs, AppLoadContext, Blocker, BlockerFunction, type Cookie, type CookieOptions, type CookieSignatureOptions, type CreateRequestHandlerFunction, Router as DataRouter, DataStrategyFunction, EntryContext, type FlashSessionData, type HandleDataRequestFunction, type HandleDocumentRequestFunction, type HandleErrorFunction, HydrationState, IndexRouteObject, InitialEntry, type IsCookieFunction, type IsSessionFunction, LinksFunction, LoaderFunction, LoaderFunctionArgs, Location, MetaFunction, type NavigateFunction, NavigateOptions, Navigation, Action as NavigationType, NonIndexRouteObject, ParamParseKey, Params$1 as Params, Path, PathMatch, PathPattern, type Register, RelativeRoutingType, type RequestHandler, RevalidationState, RouteObject, RouterState, type RoutesTestStubProps, type ServerBuild, type ServerEntryModule, ServerRouter, type ServerRouterProps, type Session, type SessionData, type SessionIdStorageStrategy, type SessionStorage, StaticHandler, StaticHandlerContext, StaticRouter, type StaticRouterProps, StaticRouterProvider, type StaticRouterProviderProps, To, UIMatch, AssetsManifest as UNSAFE_AssetsManifest, MiddlewareEnabled as UNSAFE_MiddlewareEnabled, RemixErrorBoundary as UNSAFE_RemixErrorBoundary, RouteModules as UNSAFE_RouteModules, ServerMode as UNSAFE_ServerMode, SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol, decodeViaTurboStream as UNSAFE_decodeViaTurboStream, deserializeErrors as UNSAFE_deserializeErrors, getSingleFetchDataStrategy as UNSAFE_getSingleFetchDataStrategy, createCookie, createCookieSessionStorage, createMemorySessionStorage, createRequestHandler, createRoutesStub, createSession, createSessionStorage, createStaticHandler, createStaticRouter, href, isCookie, isSession, unstable_InitialContext, unstable_RouterContextProvider, setDevServerHooks as unstable_setDevServerHooks, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };
|
||||
@@ -0,0 +1,13 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = _temporalRef;
|
||||
var _temporalUndefined = require("./temporalUndefined.js");
|
||||
var _tdz = require("./tdz.js");
|
||||
function _temporalRef(val, name) {
|
||||
return val === _temporalUndefined.default ? (0, _tdz.default)(name) : val;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=temporalRef.js.map
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"K D E F A mC","2052":"B"},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 9 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","194":"1 2 3 4 5 6 7 8 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 qC rC"},D:{"1":"0 9 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":"J PB K D E F A B C L M G N O P","322":"1 2 3 4 5 6 7 8 QB RB SB TB UB VB WB XB YB ZB aB bB cB dB","516":"eB fB gB hB iB jB kB lB"},E:{"1":"B C L M G 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","1028":"A TC"},F:{"1":"0 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":"F B C 4C 5C 6C 7C FC kC 8C GC","322":"1 2 3 4 5 6 7 8 G N O P QB","516":"RB SB TB UB VB WB XB YB"},G:{"1":"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","1028":"GD HD"},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:{"1":"B","2":"A"},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","516":"J"},Q:{"1":"oD"},R:{"1":"pD"},S:{"1":"qD rD"}},B:6,C:"let",D:true};
|
||||
@@ -0,0 +1,10 @@
|
||||
/**
|
||||
* Detect Electron renderer / nwjs process, which is node, but we should
|
||||
* treat as a browser.
|
||||
*/
|
||||
|
||||
if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
|
||||
module.exports = require('./browser.js');
|
||||
} else {
|
||||
module.exports = require('./node.js');
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
/**
|
||||
* @fileoverview A rule to warn against using arrow functions when they could be
|
||||
* confused with comparisons
|
||||
* @author Jxck <https://github.com/Jxck>
|
||||
* @deprecated in ESLint v8.53.0
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
const astUtils = require("./utils/ast-utils.js");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Checks whether or not a node is a conditional expression.
|
||||
* @param {ASTNode} node node to test
|
||||
* @returns {boolean} `true` if the node is a conditional expression.
|
||||
*/
|
||||
function isConditional(node) {
|
||||
return node && node.type === "ConditionalExpression";
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
deprecated: {
|
||||
message: "Formatting rules are being moved out of ESLint core.",
|
||||
url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
|
||||
deprecatedSince: "8.53.0",
|
||||
availableUntil: "10.0.0",
|
||||
replacedBy: [
|
||||
{
|
||||
message:
|
||||
"ESLint Stylistic now maintains deprecated stylistic core rules.",
|
||||
url: "https://eslint.style/guide/migration",
|
||||
plugin: {
|
||||
name: "@stylistic/eslint-plugin-js",
|
||||
url: "https://eslint.style/packages/js",
|
||||
},
|
||||
rule: {
|
||||
name: "no-confusing-arrow",
|
||||
url: "https://eslint.style/rules/js/no-confusing-arrow",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Disallow arrow functions where they could be confused with comparisons",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-confusing-arrow",
|
||||
},
|
||||
|
||||
fixable: "code",
|
||||
|
||||
schema: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
allowParens: { type: "boolean", default: true },
|
||||
onlyOneSimpleParam: { type: "boolean", default: false },
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
|
||||
messages: {
|
||||
confusing:
|
||||
"Arrow function used ambiguously with a conditional expression.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const config = context.options[0] || {};
|
||||
const allowParens = config.allowParens || config.allowParens === void 0;
|
||||
const onlyOneSimpleParam = config.onlyOneSimpleParam;
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
/**
|
||||
* Reports if an arrow function contains an ambiguous conditional.
|
||||
* @param {ASTNode} node A node to check and report.
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkArrowFunc(node) {
|
||||
const body = node.body;
|
||||
|
||||
if (
|
||||
isConditional(body) &&
|
||||
!(allowParens && astUtils.isParenthesised(sourceCode, body)) &&
|
||||
!(
|
||||
onlyOneSimpleParam &&
|
||||
!(
|
||||
node.params.length === 1 &&
|
||||
node.params[0].type === "Identifier"
|
||||
)
|
||||
)
|
||||
) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "confusing",
|
||||
fix(fixer) {
|
||||
// if `allowParens` is not set to true don't bother wrapping in parens
|
||||
return (
|
||||
allowParens &&
|
||||
fixer.replaceText(
|
||||
node.body,
|
||||
`(${sourceCode.getText(node.body)})`,
|
||||
)
|
||||
);
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
ArrowFunctionExpression: checkArrowFunc,
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
MIT License http://www.opensource.org/licenses/mit-license.php
|
||||
Author Tobias Koppers @sokra
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
const Hook = require("./Hook");
|
||||
const HookCodeFactory = require("./HookCodeFactory");
|
||||
|
||||
class AsyncSeriesBailHookCodeFactory extends HookCodeFactory {
|
||||
content({ onError, onResult, resultReturns, onDone }) {
|
||||
return this.callTapsSeries({
|
||||
onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
|
||||
onResult: (i, result, next) =>
|
||||
`if(${result} !== undefined) {\n${onResult(
|
||||
result
|
||||
)}\n} else {\n${next()}}\n`,
|
||||
resultReturns,
|
||||
onDone
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const factory = new AsyncSeriesBailHookCodeFactory();
|
||||
|
||||
const COMPILE = function(options) {
|
||||
factory.setup(this, options);
|
||||
return factory.create(options);
|
||||
};
|
||||
|
||||
function AsyncSeriesBailHook(args = [], name = undefined) {
|
||||
const hook = new Hook(args, name);
|
||||
hook.constructor = AsyncSeriesBailHook;
|
||||
hook.compile = COMPILE;
|
||||
hook._call = undefined;
|
||||
hook.call = undefined;
|
||||
return hook;
|
||||
}
|
||||
|
||||
AsyncSeriesBailHook.prototype = null;
|
||||
|
||||
module.exports = AsyncSeriesBailHook;
|
||||
@@ -0,0 +1,52 @@
|
||||
'use strict';
|
||||
|
||||
const path = require('path');
|
||||
const which = require('which');
|
||||
const getPathKey = require('path-key');
|
||||
|
||||
function resolveCommandAttempt(parsed, withoutPathExt) {
|
||||
const env = parsed.options.env || process.env;
|
||||
const cwd = process.cwd();
|
||||
const hasCustomCwd = parsed.options.cwd != null;
|
||||
// Worker threads do not have process.chdir()
|
||||
const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
|
||||
|
||||
// If a custom `cwd` was specified, we need to change the process cwd
|
||||
// because `which` will do stat calls but does not support a custom cwd
|
||||
if (shouldSwitchCwd) {
|
||||
try {
|
||||
process.chdir(parsed.options.cwd);
|
||||
} catch (err) {
|
||||
/* Empty */
|
||||
}
|
||||
}
|
||||
|
||||
let resolved;
|
||||
|
||||
try {
|
||||
resolved = which.sync(parsed.command, {
|
||||
path: env[getPathKey({ env })],
|
||||
pathExt: withoutPathExt ? path.delimiter : undefined,
|
||||
});
|
||||
} catch (e) {
|
||||
/* Empty */
|
||||
} finally {
|
||||
if (shouldSwitchCwd) {
|
||||
process.chdir(cwd);
|
||||
}
|
||||
}
|
||||
|
||||
// If we successfully resolved, ensure that an absolute path is returned
|
||||
// Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it
|
||||
if (resolved) {
|
||||
resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
|
||||
}
|
||||
|
||||
return resolved;
|
||||
}
|
||||
|
||||
function resolveCommand(parsed) {
|
||||
return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
|
||||
}
|
||||
|
||||
module.exports = resolveCommand;
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"K D E F A B mC"},B:{"2":"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","260":"0 9 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 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","260":"0 9 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 sC SC tC uC vC","260":"F","420":"A B C L M G 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 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 4C 5C 6C 7C FC kC 8C GC","260":"0 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","420":"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 XD YD ZD aD lC bD cD","260":"I"},J:{"2":"D A"},K:{"2":"A B C FC kC GC","260":"H"},L:{"260":"I"},M:{"2":"EC"},N:{"2":"A B"},O:{"2":"HC"},P:{"2":"1 J dD eD fD gD hD TC iD jD kD lD mD IC JC KC nD","260":"2 3 4 5 6 7 8"},Q:{"2":"oD"},R:{"2":"pD"},S:{"2":"qD rD"}},B:5,C:"CSS Initial Letter",D:true};
|
||||
@@ -0,0 +1,9 @@
|
||||
'use client';
|
||||
|
||||
import { createContext } from 'react';
|
||||
|
||||
import type { PageContextType } from './shared/types.js';
|
||||
|
||||
const pageContext: React.Context<PageContextType> = createContext<PageContextType>(null);
|
||||
|
||||
export default pageContext;
|
||||
@@ -0,0 +1,174 @@
|
||||
### esutils [](http://travis-ci.org/estools/esutils)
|
||||
esutils ([esutils](http://github.com/estools/esutils)) is
|
||||
utility box for ECMAScript language tools.
|
||||
|
||||
### API
|
||||
|
||||
### ast
|
||||
|
||||
#### ast.isExpression(node)
|
||||
|
||||
Returns true if `node` is an Expression as defined in ECMA262 edition 5.1 section
|
||||
[11](https://es5.github.io/#x11).
|
||||
|
||||
#### ast.isStatement(node)
|
||||
|
||||
Returns true if `node` is a Statement as defined in ECMA262 edition 5.1 section
|
||||
[12](https://es5.github.io/#x12).
|
||||
|
||||
#### ast.isIterationStatement(node)
|
||||
|
||||
Returns true if `node` is an IterationStatement as defined in ECMA262 edition
|
||||
5.1 section [12.6](https://es5.github.io/#x12.6).
|
||||
|
||||
#### ast.isSourceElement(node)
|
||||
|
||||
Returns true if `node` is a SourceElement as defined in ECMA262 edition 5.1
|
||||
section [14](https://es5.github.io/#x14).
|
||||
|
||||
#### ast.trailingStatement(node)
|
||||
|
||||
Returns `Statement?` if `node` has trailing `Statement`.
|
||||
```js
|
||||
if (cond)
|
||||
consequent;
|
||||
```
|
||||
When taking this `IfStatement`, returns `consequent;` statement.
|
||||
|
||||
#### ast.isProblematicIfStatement(node)
|
||||
|
||||
Returns true if `node` is a problematic IfStatement. If `node` is a problematic `IfStatement`, `node` cannot be represented as an one on one JavaScript code.
|
||||
```js
|
||||
{
|
||||
type: 'IfStatement',
|
||||
consequent: {
|
||||
type: 'WithStatement',
|
||||
body: {
|
||||
type: 'IfStatement',
|
||||
consequent: {type: 'EmptyStatement'}
|
||||
}
|
||||
},
|
||||
alternate: {type: 'EmptyStatement'}
|
||||
}
|
||||
```
|
||||
The above node cannot be represented as a JavaScript code, since the top level `else` alternate belongs to an inner `IfStatement`.
|
||||
|
||||
|
||||
### code
|
||||
|
||||
#### code.isDecimalDigit(code)
|
||||
|
||||
Return true if provided code is decimal digit.
|
||||
|
||||
#### code.isHexDigit(code)
|
||||
|
||||
Return true if provided code is hexadecimal digit.
|
||||
|
||||
#### code.isOctalDigit(code)
|
||||
|
||||
Return true if provided code is octal digit.
|
||||
|
||||
#### code.isWhiteSpace(code)
|
||||
|
||||
Return true if provided code is white space. White space characters are formally defined in ECMA262.
|
||||
|
||||
#### code.isLineTerminator(code)
|
||||
|
||||
Return true if provided code is line terminator. Line terminator characters are formally defined in ECMA262.
|
||||
|
||||
#### code.isIdentifierStart(code)
|
||||
|
||||
Return true if provided code can be the first character of ECMA262 Identifier. They are formally defined in ECMA262.
|
||||
|
||||
#### code.isIdentifierPart(code)
|
||||
|
||||
Return true if provided code can be the trailing character of ECMA262 Identifier. They are formally defined in ECMA262.
|
||||
|
||||
### keyword
|
||||
|
||||
#### keyword.isKeywordES5(id, strict)
|
||||
|
||||
Returns `true` if provided identifier string is a Keyword or Future Reserved Word
|
||||
in ECMA262 edition 5.1. They are formally defined in ECMA262 sections
|
||||
[7.6.1.1](http://es5.github.io/#x7.6.1.1) and [7.6.1.2](http://es5.github.io/#x7.6.1.2),
|
||||
respectively. If the `strict` flag is truthy, this function additionally checks whether
|
||||
`id` is a Keyword or Future Reserved Word under strict mode.
|
||||
|
||||
#### keyword.isKeywordES6(id, strict)
|
||||
|
||||
Returns `true` if provided identifier string is a Keyword or Future Reserved Word
|
||||
in ECMA262 edition 6. They are formally defined in ECMA262 sections
|
||||
[11.6.2.1](http://ecma-international.org/ecma-262/6.0/#sec-keywords) and
|
||||
[11.6.2.2](http://ecma-international.org/ecma-262/6.0/#sec-future-reserved-words),
|
||||
respectively. If the `strict` flag is truthy, this function additionally checks whether
|
||||
`id` is a Keyword or Future Reserved Word under strict mode.
|
||||
|
||||
#### keyword.isReservedWordES5(id, strict)
|
||||
|
||||
Returns `true` if provided identifier string is a Reserved Word in ECMA262 edition 5.1.
|
||||
They are formally defined in ECMA262 section [7.6.1](http://es5.github.io/#x7.6.1).
|
||||
If the `strict` flag is truthy, this function additionally checks whether `id`
|
||||
is a Reserved Word under strict mode.
|
||||
|
||||
#### keyword.isReservedWordES6(id, strict)
|
||||
|
||||
Returns `true` if provided identifier string is a Reserved Word in ECMA262 edition 6.
|
||||
They are formally defined in ECMA262 section [11.6.2](http://ecma-international.org/ecma-262/6.0/#sec-reserved-words).
|
||||
If the `strict` flag is truthy, this function additionally checks whether `id`
|
||||
is a Reserved Word under strict mode.
|
||||
|
||||
#### keyword.isRestrictedWord(id)
|
||||
|
||||
Returns `true` if provided identifier string is one of `eval` or `arguments`.
|
||||
They are restricted in strict mode code throughout ECMA262 edition 5.1 and
|
||||
in ECMA262 edition 6 section [12.1.1](http://ecma-international.org/ecma-262/6.0/#sec-identifiers-static-semantics-early-errors).
|
||||
|
||||
#### keyword.isIdentifierNameES5(id)
|
||||
|
||||
Return true if provided identifier string is an IdentifierName as specified in
|
||||
ECMA262 edition 5.1 section [7.6](https://es5.github.io/#x7.6).
|
||||
|
||||
#### keyword.isIdentifierNameES6(id)
|
||||
|
||||
Return true if provided identifier string is an IdentifierName as specified in
|
||||
ECMA262 edition 6 section [11.6](http://ecma-international.org/ecma-262/6.0/#sec-names-and-keywords).
|
||||
|
||||
#### keyword.isIdentifierES5(id, strict)
|
||||
|
||||
Return true if provided identifier string is an Identifier as specified in
|
||||
ECMA262 edition 5.1 section [7.6](https://es5.github.io/#x7.6). If the `strict`
|
||||
flag is truthy, this function additionally checks whether `id` is an Identifier
|
||||
under strict mode.
|
||||
|
||||
#### keyword.isIdentifierES6(id, strict)
|
||||
|
||||
Return true if provided identifier string is an Identifier as specified in
|
||||
ECMA262 edition 6 section [12.1](http://ecma-international.org/ecma-262/6.0/#sec-identifiers).
|
||||
If the `strict` flag is truthy, this function additionally checks whether `id`
|
||||
is an Identifier under strict mode.
|
||||
|
||||
### License
|
||||
|
||||
Copyright (C) 2013 [Yusuke Suzuki](http://github.com/Constellation)
|
||||
(twitter: [@Constellation](http://twitter.com/Constellation)) and other contributors.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
@@ -0,0 +1,45 @@
|
||||
/**
|
||||
* @fileoverview disallow using an async function as a Promise executor
|
||||
* @author Teddy Katz
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "problem",
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Disallow using an async function as a Promise executor",
|
||||
recommended: true,
|
||||
url: "https://eslint.org/docs/latest/rules/no-async-promise-executor",
|
||||
},
|
||||
|
||||
fixable: null,
|
||||
schema: [],
|
||||
messages: {
|
||||
async: "Promise executor functions should not be async.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
return {
|
||||
"NewExpression[callee.name='Promise'][arguments.0.async=true]"(
|
||||
node,
|
||||
) {
|
||||
context.report({
|
||||
node: context.sourceCode.getFirstToken(
|
||||
node.arguments[0],
|
||||
token => token.value === "async",
|
||||
),
|
||||
messageId: "async",
|
||||
});
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_defineEnumerableProperties","obj","descs","key","desc","configurable","enumerable","writable","Object","defineProperty","getOwnPropertySymbols","objectSymbols","i","length","sym"],"sources":["../../src/helpers/defineEnumerableProperties.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n/* @onlyBabel7 */\nexport default function _defineEnumerableProperties<T>(\n obj: T,\n descs: { [key: string | symbol]: PropertyDescriptor },\n): T {\n // eslint-disable-next-line guard-for-in\n for (var key in descs) {\n var desc = descs[key];\n desc.configurable = desc.enumerable = true;\n if (\"value\" in desc) desc.writable = true;\n Object.defineProperty(obj, key, desc);\n }\n\n // Symbols are not enumerated over by for-in loops. If native\n // Symbols are available, fetch all of the descs object's own\n // symbol properties and define them on our target object too.\n if (Object.getOwnPropertySymbols) {\n var objectSymbols = Object.getOwnPropertySymbols(descs);\n for (var i = 0; i < objectSymbols.length; i++) {\n var sym = objectSymbols[i];\n desc = descs[sym];\n desc.configurable = desc.enumerable = true;\n if (\"value\" in desc) desc.writable = true;\n Object.defineProperty(obj, sym, desc);\n }\n }\n return obj;\n}\n"],"mappings":";;;;;;AAEe,SAASA,2BAA2BA,CACjDC,GAAM,EACNC,KAAqD,EAClD;EAEH,KAAK,IAAIC,GAAG,IAAID,KAAK,EAAE;IACrB,IAAIE,IAAI,GAAGF,KAAK,CAACC,GAAG,CAAC;IACrBC,IAAI,CAACC,YAAY,GAAGD,IAAI,CAACE,UAAU,GAAG,IAAI;IAC1C,IAAI,OAAO,IAAIF,IAAI,EAAEA,IAAI,CAACG,QAAQ,GAAG,IAAI;IACzCC,MAAM,CAACC,cAAc,CAACR,GAAG,EAAEE,GAAG,EAAEC,IAAI,CAAC;EACvC;EAKA,IAAII,MAAM,CAACE,qBAAqB,EAAE;IAChC,IAAIC,aAAa,GAAGH,MAAM,CAACE,qBAAqB,CAACR,KAAK,CAAC;IACvD,KAAK,IAAIU,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGD,aAAa,CAACE,MAAM,EAAED,CAAC,EAAE,EAAE;MAC7C,IAAIE,GAAG,GAAGH,aAAa,CAACC,CAAC,CAAC;MAC1BR,IAAI,GAAGF,KAAK,CAACY,GAAG,CAAC;MACjBV,IAAI,CAACC,YAAY,GAAGD,IAAI,CAACE,UAAU,GAAG,IAAI;MAC1C,IAAI,OAAO,IAAIF,IAAI,EAAEA,IAAI,CAACG,QAAQ,GAAG,IAAI;MACzCC,MAAM,CAACC,cAAc,CAACR,GAAG,EAAEa,GAAG,EAAEV,IAAI,CAAC;IACvC;EACF;EACA,OAAOH,GAAG;AACZ","ignoreList":[]}
|
||||
@@ -0,0 +1,5 @@
|
||||
import { Parser } from "../index.js";
|
||||
|
||||
export declare const parsers: {
|
||||
glimmer: Parser;
|
||||
};
|
||||
Reference in New Issue
Block a user