WIP: bootstrap and partial real Solana watcher implementation
This commit is contained in:
@@ -0,0 +1,198 @@
|
||||
// Generated by LiveScript 1.6.0
|
||||
(function(){
|
||||
var identifierRegex, tokenRegex;
|
||||
identifierRegex = /[\$\w]+/;
|
||||
function peek(tokens){
|
||||
var token;
|
||||
token = tokens[0];
|
||||
if (token == null) {
|
||||
throw new Error('Unexpected end of input.');
|
||||
}
|
||||
return token;
|
||||
}
|
||||
function consumeIdent(tokens){
|
||||
var token;
|
||||
token = peek(tokens);
|
||||
if (!identifierRegex.test(token)) {
|
||||
throw new Error("Expected text, got '" + token + "' instead.");
|
||||
}
|
||||
return tokens.shift();
|
||||
}
|
||||
function consumeOp(tokens, op){
|
||||
var token;
|
||||
token = peek(tokens);
|
||||
if (token !== op) {
|
||||
throw new Error("Expected '" + op + "', got '" + token + "' instead.");
|
||||
}
|
||||
return tokens.shift();
|
||||
}
|
||||
function maybeConsumeOp(tokens, op){
|
||||
var token;
|
||||
token = tokens[0];
|
||||
if (token === op) {
|
||||
return tokens.shift();
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
function consumeArray(tokens){
|
||||
var types;
|
||||
consumeOp(tokens, '[');
|
||||
if (peek(tokens) === ']') {
|
||||
throw new Error("Must specify type of Array - eg. [Type], got [] instead.");
|
||||
}
|
||||
types = consumeTypes(tokens);
|
||||
consumeOp(tokens, ']');
|
||||
return {
|
||||
structure: 'array',
|
||||
of: types
|
||||
};
|
||||
}
|
||||
function consumeTuple(tokens){
|
||||
var components;
|
||||
components = [];
|
||||
consumeOp(tokens, '(');
|
||||
if (peek(tokens) === ')') {
|
||||
throw new Error("Tuple must be of at least length 1 - eg. (Type), got () instead.");
|
||||
}
|
||||
for (;;) {
|
||||
components.push(consumeTypes(tokens));
|
||||
maybeConsumeOp(tokens, ',');
|
||||
if (')' === peek(tokens)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
consumeOp(tokens, ')');
|
||||
return {
|
||||
structure: 'tuple',
|
||||
of: components
|
||||
};
|
||||
}
|
||||
function consumeFields(tokens){
|
||||
var fields, subset, ref$, key, types;
|
||||
fields = {};
|
||||
consumeOp(tokens, '{');
|
||||
subset = false;
|
||||
for (;;) {
|
||||
if (maybeConsumeOp(tokens, '...')) {
|
||||
subset = true;
|
||||
break;
|
||||
}
|
||||
ref$ = consumeField(tokens), key = ref$[0], types = ref$[1];
|
||||
fields[key] = types;
|
||||
maybeConsumeOp(tokens, ',');
|
||||
if ('}' === peek(tokens)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
consumeOp(tokens, '}');
|
||||
return {
|
||||
structure: 'fields',
|
||||
of: fields,
|
||||
subset: subset
|
||||
};
|
||||
}
|
||||
function consumeField(tokens){
|
||||
var key, types;
|
||||
key = consumeIdent(tokens);
|
||||
consumeOp(tokens, ':');
|
||||
types = consumeTypes(tokens);
|
||||
return [key, types];
|
||||
}
|
||||
function maybeConsumeStructure(tokens){
|
||||
switch (tokens[0]) {
|
||||
case '[':
|
||||
return consumeArray(tokens);
|
||||
case '(':
|
||||
return consumeTuple(tokens);
|
||||
case '{':
|
||||
return consumeFields(tokens);
|
||||
}
|
||||
}
|
||||
function consumeType(tokens){
|
||||
var token, wildcard, type, structure;
|
||||
token = peek(tokens);
|
||||
wildcard = token === '*';
|
||||
if (wildcard || identifierRegex.test(token)) {
|
||||
type = wildcard
|
||||
? consumeOp(tokens, '*')
|
||||
: consumeIdent(tokens);
|
||||
structure = maybeConsumeStructure(tokens);
|
||||
if (structure) {
|
||||
return structure.type = type, structure;
|
||||
} else {
|
||||
return {
|
||||
type: type
|
||||
};
|
||||
}
|
||||
} else {
|
||||
structure = maybeConsumeStructure(tokens);
|
||||
if (!structure) {
|
||||
throw new Error("Unexpected character: " + token);
|
||||
}
|
||||
return structure;
|
||||
}
|
||||
}
|
||||
function consumeTypes(tokens){
|
||||
var lookahead, types, typesSoFar, typeObj, type, structure;
|
||||
if ('::' === peek(tokens)) {
|
||||
throw new Error("No comment before comment separator '::' found.");
|
||||
}
|
||||
lookahead = tokens[1];
|
||||
if (lookahead != null && lookahead === '::') {
|
||||
tokens.shift();
|
||||
tokens.shift();
|
||||
}
|
||||
types = [];
|
||||
typesSoFar = {};
|
||||
if ('Maybe' === peek(tokens)) {
|
||||
tokens.shift();
|
||||
types = [
|
||||
{
|
||||
type: 'Undefined'
|
||||
}, {
|
||||
type: 'Null'
|
||||
}
|
||||
];
|
||||
typesSoFar = {
|
||||
Undefined: true,
|
||||
Null: true
|
||||
};
|
||||
}
|
||||
for (;;) {
|
||||
typeObj = consumeType(tokens), type = typeObj.type, structure = typeObj.structure;
|
||||
if (!typesSoFar[type]) {
|
||||
types.push(typeObj);
|
||||
}
|
||||
if (structure == null) {
|
||||
typesSoFar[type] = true;
|
||||
}
|
||||
if (!maybeConsumeOp(tokens, '|')) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return types;
|
||||
}
|
||||
tokenRegex = RegExp('\\.\\.\\.|::|->|' + identifierRegex.source + '|\\S', 'g');
|
||||
module.exports = function(input){
|
||||
var tokens, e;
|
||||
if (!input.length) {
|
||||
throw new Error('No type specified.');
|
||||
}
|
||||
tokens = input.match(tokenRegex) || [];
|
||||
if (in$('->', tokens)) {
|
||||
throw new Error("Function types are not supported.\ To validate that something is a function, you may use 'Function'.");
|
||||
}
|
||||
try {
|
||||
return consumeTypes(tokens);
|
||||
} catch (e$) {
|
||||
e = e$;
|
||||
throw new Error(e.message + " - Remaining tokens: " + JSON.stringify(tokens) + " - Initial input: '" + input + "'");
|
||||
}
|
||||
};
|
||||
function in$(x, xs){
|
||||
var i = -1, l = xs.length >>> 0;
|
||||
while (++i < l) if (x === xs[i]) return true;
|
||||
return false;
|
||||
}
|
||||
}).call(this);
|
||||
@@ -0,0 +1,16 @@
|
||||
'use strict'
|
||||
|
||||
const { test } = require('node:test')
|
||||
const joinLinesWithIndentation = require('./join-lines-with-indentation')
|
||||
|
||||
test('joinLinesWithIndentation adds indentation to beginning of subsequent lines', t => {
|
||||
const input = 'foo\nbar\nbaz'
|
||||
const result = joinLinesWithIndentation({ input })
|
||||
t.assert.strictEqual(result, 'foo\n bar\n baz')
|
||||
})
|
||||
|
||||
test('joinLinesWithIndentation accepts custom indentation, line breaks, and eol', t => {
|
||||
const input = 'foo\nbar\r\nbaz'
|
||||
const result = joinLinesWithIndentation({ input, ident: ' ', eol: '^' })
|
||||
t.assert.strictEqual(result, 'foo^ bar^ baz')
|
||||
})
|
||||
@@ -0,0 +1,6 @@
|
||||
export * from "./errors.js";
|
||||
export * from "./helpers/parseUtil.js";
|
||||
export * from "./helpers/typeAliases.js";
|
||||
export * from "./helpers/util.js";
|
||||
export * from "./types.js";
|
||||
export * from "./ZodError.js";
|
||||
@@ -0,0 +1,50 @@
|
||||
//#region src/log/logging.d.ts
|
||||
/** @inline */
|
||||
type LogLevel = "info" | "debug" | "warn";
|
||||
/** @inline */
|
||||
type LogLevelOption = LogLevel | "silent";
|
||||
/** @inline */
|
||||
type LogLevelWithError = LogLevel | "error";
|
||||
interface RolldownLog {
|
||||
binding?: string;
|
||||
cause?: unknown;
|
||||
/**
|
||||
* The log code for this log object.
|
||||
* @example 'PLUGIN_ERROR'
|
||||
*/
|
||||
code?: string;
|
||||
exporter?: string;
|
||||
frame?: string;
|
||||
hook?: string;
|
||||
id?: string;
|
||||
ids?: string[];
|
||||
loc?: {
|
||||
column: number;
|
||||
file?: string;
|
||||
line: number;
|
||||
};
|
||||
/**
|
||||
* The message for this log object.
|
||||
* @example 'The "transform" hook used by the output plugin "rolldown-plugin-foo" is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.'
|
||||
*/
|
||||
message: string;
|
||||
meta?: any;
|
||||
names?: string[];
|
||||
plugin?: string;
|
||||
pluginCode?: unknown;
|
||||
pos?: number;
|
||||
reexporter?: string;
|
||||
stack?: string;
|
||||
url?: string;
|
||||
}
|
||||
/** @inline */
|
||||
type RolldownLogWithString = RolldownLog | string;
|
||||
/** @category Plugin APIs */
|
||||
interface RolldownError extends RolldownLog {
|
||||
name?: string;
|
||||
stack?: string;
|
||||
watchFiles?: string[];
|
||||
}
|
||||
type LogOrStringHandler = (level: LogLevelWithError, log: RolldownLogWithString) => void;
|
||||
//#endregion
|
||||
export { RolldownLog as a, RolldownError as i, LogLevelOption as n, RolldownLogWithString as o, LogOrStringHandler as r, LogLevel as t };
|
||||
@@ -0,0 +1,135 @@
|
||||
"use strict";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.default = default_1;
|
||||
const util = __importStar(require("../core/util.cjs"));
|
||||
const error = () => {
|
||||
const Sizable = {
|
||||
string: { unit: "tegn", verb: "å ha" },
|
||||
file: { unit: "bytes", verb: "å ha" },
|
||||
array: { unit: "elementer", verb: "å inneholde" },
|
||||
set: { unit: "elementer", verb: "å inneholde" },
|
||||
};
|
||||
function getSizing(origin) {
|
||||
return Sizable[origin] ?? null;
|
||||
}
|
||||
const FormatDictionary = {
|
||||
regex: "input",
|
||||
email: "e-postadresse",
|
||||
url: "URL",
|
||||
emoji: "emoji",
|
||||
uuid: "UUID",
|
||||
uuidv4: "UUIDv4",
|
||||
uuidv6: "UUIDv6",
|
||||
nanoid: "nanoid",
|
||||
guid: "GUID",
|
||||
cuid: "cuid",
|
||||
cuid2: "cuid2",
|
||||
ulid: "ULID",
|
||||
xid: "XID",
|
||||
ksuid: "KSUID",
|
||||
datetime: "ISO dato- og klokkeslett",
|
||||
date: "ISO-dato",
|
||||
time: "ISO-klokkeslett",
|
||||
duration: "ISO-varighet",
|
||||
ipv4: "IPv4-område",
|
||||
ipv6: "IPv6-område",
|
||||
cidrv4: "IPv4-spekter",
|
||||
cidrv6: "IPv6-spekter",
|
||||
base64: "base64-enkodet streng",
|
||||
base64url: "base64url-enkodet streng",
|
||||
json_string: "JSON-streng",
|
||||
e164: "E.164-nummer",
|
||||
jwt: "JWT",
|
||||
template_literal: "input",
|
||||
};
|
||||
const TypeDictionary = {
|
||||
nan: "NaN",
|
||||
number: "tall",
|
||||
array: "liste",
|
||||
};
|
||||
return (issue) => {
|
||||
switch (issue.code) {
|
||||
case "invalid_type": {
|
||||
const expected = TypeDictionary[issue.expected] ?? issue.expected;
|
||||
const receivedType = util.parsedType(issue.input);
|
||||
const received = TypeDictionary[receivedType] ?? receivedType;
|
||||
if (/^[A-Z]/.test(issue.expected)) {
|
||||
return `Ugyldig input: forventet instanceof ${issue.expected}, fikk ${received}`;
|
||||
}
|
||||
return `Ugyldig input: forventet ${expected}, fikk ${received}`;
|
||||
}
|
||||
case "invalid_value":
|
||||
if (issue.values.length === 1)
|
||||
return `Ugyldig verdi: forventet ${util.stringifyPrimitive(issue.values[0])}`;
|
||||
return `Ugyldig valg: forventet en av ${util.joinValues(issue.values, "|")}`;
|
||||
case "too_big": {
|
||||
const adj = issue.inclusive ? "<=" : "<";
|
||||
const sizing = getSizing(issue.origin);
|
||||
if (sizing)
|
||||
return `For stor(t): forventet ${issue.origin ?? "value"} til å ha ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementer"}`;
|
||||
return `For stor(t): forventet ${issue.origin ?? "value"} til å ha ${adj}${issue.maximum.toString()}`;
|
||||
}
|
||||
case "too_small": {
|
||||
const adj = issue.inclusive ? ">=" : ">";
|
||||
const sizing = getSizing(issue.origin);
|
||||
if (sizing) {
|
||||
return `For lite(n): forventet ${issue.origin} til å ha ${adj}${issue.minimum.toString()} ${sizing.unit}`;
|
||||
}
|
||||
return `For lite(n): forventet ${issue.origin} til å ha ${adj}${issue.minimum.toString()}`;
|
||||
}
|
||||
case "invalid_format": {
|
||||
const _issue = issue;
|
||||
if (_issue.format === "starts_with")
|
||||
return `Ugyldig streng: må starte med "${_issue.prefix}"`;
|
||||
if (_issue.format === "ends_with")
|
||||
return `Ugyldig streng: må ende med "${_issue.suffix}"`;
|
||||
if (_issue.format === "includes")
|
||||
return `Ugyldig streng: må inneholde "${_issue.includes}"`;
|
||||
if (_issue.format === "regex")
|
||||
return `Ugyldig streng: må matche mønsteret ${_issue.pattern}`;
|
||||
return `Ugyldig ${FormatDictionary[_issue.format] ?? issue.format}`;
|
||||
}
|
||||
case "not_multiple_of":
|
||||
return `Ugyldig tall: må være et multiplum av ${issue.divisor}`;
|
||||
case "unrecognized_keys":
|
||||
return `${issue.keys.length > 1 ? "Ukjente nøkler" : "Ukjent nøkkel"}: ${util.joinValues(issue.keys, ", ")}`;
|
||||
case "invalid_key":
|
||||
return `Ugyldig nøkkel i ${issue.origin}`;
|
||||
case "invalid_union":
|
||||
return "Ugyldig input";
|
||||
case "invalid_element":
|
||||
return `Ugyldig verdi i ${issue.origin}`;
|
||||
default:
|
||||
return `Ugyldig input`;
|
||||
}
|
||||
};
|
||||
};
|
||||
function default_1() {
|
||||
return {
|
||||
localeError: error(),
|
||||
};
|
||||
}
|
||||
module.exports = exports.default;
|
||||
@@ -0,0 +1,10 @@
|
||||
'use strict';
|
||||
|
||||
var parse = require('../');
|
||||
var test = require('tape');
|
||||
|
||||
test('whitespace should be whitespace', function (t) {
|
||||
t.plan(1);
|
||||
var x = parse(['-x', '\t']).x;
|
||||
t.equal(x, '\t');
|
||||
});
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,GACnB,GAAG,MAAM,GAAG,MAAM,EAClB,GAAG,MAAM,GAAG,MAAM,EAClB,KAAK,MAAM;;;;;;aAgBZ,CAAA;AAOD,eAAO,MAAM,KAAK,GAChB,GAAG,MAAM,EACT,GAAG,MAAM,EACT,KAAK,MAAM,KACV,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,CA2C7B,CAAA"}
|
||||
@@ -0,0 +1,5 @@
|
||||
import checkPrivateRedeclaration from "./checkPrivateRedeclaration.js";
|
||||
function _classPrivateFieldInitSpec(e, t, a) {
|
||||
checkPrivateRedeclaration(e, t), t.set(e, a);
|
||||
}
|
||||
export { _classPrivateFieldInitSpec as default };
|
||||
@@ -0,0 +1,118 @@
|
||||
declare module 'dgram' {
|
||||
import { AddressInfo } from 'net';
|
||||
import * as dns from 'dns';
|
||||
import EventEmitter = require('events');
|
||||
|
||||
interface RemoteInfo {
|
||||
address: string;
|
||||
family: 'IPv4' | 'IPv6';
|
||||
port: number;
|
||||
size: number;
|
||||
}
|
||||
|
||||
interface BindOptions {
|
||||
port?: number | undefined;
|
||||
address?: string | undefined;
|
||||
exclusive?: boolean | undefined;
|
||||
fd?: number | undefined;
|
||||
}
|
||||
|
||||
type SocketType = "udp4" | "udp6";
|
||||
|
||||
interface SocketOptions {
|
||||
type: SocketType;
|
||||
reuseAddr?: boolean | undefined;
|
||||
/**
|
||||
* @default false
|
||||
*/
|
||||
ipv6Only?: boolean | undefined;
|
||||
recvBufferSize?: number | undefined;
|
||||
sendBufferSize?: number | undefined;
|
||||
lookup?: ((hostname: string, options: dns.LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void) => void) | undefined;
|
||||
}
|
||||
|
||||
function createSocket(type: SocketType, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
|
||||
function createSocket(options: SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
|
||||
|
||||
class Socket extends EventEmitter {
|
||||
addMembership(multicastAddress: string, multicastInterface?: string): void;
|
||||
address(): AddressInfo;
|
||||
bind(port?: number, address?: string, callback?: () => void): this;
|
||||
bind(port?: number, callback?: () => void): this;
|
||||
bind(callback?: () => void): this;
|
||||
bind(options: BindOptions, callback?: () => void): this;
|
||||
close(callback?: () => void): this;
|
||||
connect(port: number, address?: string, callback?: () => void): void;
|
||||
connect(port: number, callback: () => void): void;
|
||||
disconnect(): void;
|
||||
dropMembership(multicastAddress: string, multicastInterface?: string): void;
|
||||
getRecvBufferSize(): number;
|
||||
getSendBufferSize(): number;
|
||||
ref(): this;
|
||||
remoteAddress(): AddressInfo;
|
||||
send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
|
||||
send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
|
||||
send(msg: string | Uint8Array | ReadonlyArray<any>, callback?: (error: Error | null, bytes: number) => void): void;
|
||||
send(msg: string | Uint8Array, offset: number, length: number, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
|
||||
send(msg: string | Uint8Array, offset: number, length: number, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
|
||||
send(msg: string | Uint8Array, offset: number, length: number, callback?: (error: Error | null, bytes: number) => void): void;
|
||||
setBroadcast(flag: boolean): void;
|
||||
setMulticastInterface(multicastInterface: string): void;
|
||||
setMulticastLoopback(flag: boolean): boolean;
|
||||
setMulticastTTL(ttl: number): number;
|
||||
setRecvBufferSize(size: number): void;
|
||||
setSendBufferSize(size: number): void;
|
||||
setTTL(ttl: number): number;
|
||||
unref(): this;
|
||||
|
||||
/**
|
||||
* events.EventEmitter
|
||||
* 1. close
|
||||
* 2. connect
|
||||
* 3. error
|
||||
* 4. listening
|
||||
* 5. message
|
||||
*/
|
||||
addListener(event: string, listener: (...args: any[]) => void): this;
|
||||
addListener(event: "close", listener: () => void): this;
|
||||
addListener(event: "connect", listener: () => void): this;
|
||||
addListener(event: "error", listener: (err: Error) => void): this;
|
||||
addListener(event: "listening", listener: () => void): this;
|
||||
addListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
|
||||
|
||||
emit(event: string | symbol, ...args: any[]): boolean;
|
||||
emit(event: "close"): boolean;
|
||||
emit(event: "connect"): boolean;
|
||||
emit(event: "error", err: Error): boolean;
|
||||
emit(event: "listening"): boolean;
|
||||
emit(event: "message", msg: Buffer, rinfo: RemoteInfo): boolean;
|
||||
|
||||
on(event: string, listener: (...args: any[]) => void): this;
|
||||
on(event: "close", listener: () => void): this;
|
||||
on(event: "connect", listener: () => void): this;
|
||||
on(event: "error", listener: (err: Error) => void): this;
|
||||
on(event: "listening", listener: () => void): this;
|
||||
on(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
|
||||
|
||||
once(event: string, listener: (...args: any[]) => void): this;
|
||||
once(event: "close", listener: () => void): this;
|
||||
once(event: "connect", listener: () => void): this;
|
||||
once(event: "error", listener: (err: Error) => void): this;
|
||||
once(event: "listening", listener: () => void): this;
|
||||
once(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
|
||||
|
||||
prependListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependListener(event: "close", listener: () => void): this;
|
||||
prependListener(event: "connect", listener: () => void): this;
|
||||
prependListener(event: "error", listener: (err: Error) => void): this;
|
||||
prependListener(event: "listening", listener: () => void): this;
|
||||
prependListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
|
||||
|
||||
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependOnceListener(event: "close", listener: () => void): this;
|
||||
prependOnceListener(event: "connect", listener: () => void): this;
|
||||
prependOnceListener(event: "error", listener: (err: Error) => void): this;
|
||||
prependOnceListener(event: "listening", listener: () => void): this;
|
||||
prependOnceListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
import _typeof from "./typeof.js";
|
||||
function _interopRequireWildcard(e, t) {
|
||||
if ("function" == typeof WeakMap) var r = new WeakMap(),
|
||||
n = new WeakMap();
|
||||
return (_interopRequireWildcard = function _interopRequireWildcard(e, t) {
|
||||
if (!t && e && e.__esModule) return e;
|
||||
var o,
|
||||
i,
|
||||
f = {
|
||||
__proto__: null,
|
||||
"default": e
|
||||
};
|
||||
if (null === e || "object" != _typeof(e) && "function" != typeof e) return f;
|
||||
if (o = t ? n : r) {
|
||||
if (o.has(e)) return o.get(e);
|
||||
o.set(e, f);
|
||||
}
|
||||
for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]);
|
||||
return f;
|
||||
})(e, t);
|
||||
}
|
||||
export { _interopRequireWildcard as default };
|
||||
@@ -0,0 +1,22 @@
|
||||
Copyright (c) George Zahariev
|
||||
|
||||
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,68 @@
|
||||
import { expect, expectTypeOf, test } from "vitest";
|
||||
import { type ZodCustomStringFormat, hash } from "zod"; // adjust path as needed
|
||||
|
||||
test("hash() API — types and runtime across all alg/enc combinations", async () => {
|
||||
const { createHash } = await import("node:crypto");
|
||||
|
||||
type Alg = "md5" | "sha1" | "sha256" | "sha384" | "sha512";
|
||||
// type Enc = "hex" | "base64" | "base64url";
|
||||
|
||||
const toB64Url = (b64: string) => b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
|
||||
|
||||
const makeDigests = (alg: Alg, input: string) => {
|
||||
const buf = createHash(alg).update(input).digest();
|
||||
const hex = buf.toString("hex");
|
||||
const base64 = buf.toString("base64");
|
||||
const base64url = toB64Url(base64);
|
||||
return { hex, base64, base64url };
|
||||
};
|
||||
|
||||
const algs: ReadonlyArray<Alg> = ["md5", "sha1", "sha256", "sha384", "sha512"];
|
||||
const input = "zodasklfjaasdf";
|
||||
|
||||
// --- Type-level checks (ensure the literal format string is encoded in the return type)
|
||||
expectTypeOf(hash("md5")).toEqualTypeOf<ZodCustomStringFormat<"md5_hex">>();
|
||||
expectTypeOf(hash("sha1")).toEqualTypeOf<ZodCustomStringFormat<"sha1_hex">>();
|
||||
expectTypeOf(hash("sha256", { enc: "base64" as const })).toEqualTypeOf<ZodCustomStringFormat<"sha256_base64">>();
|
||||
expectTypeOf(hash("sha384", { enc: "base64url" as const })).toEqualTypeOf<
|
||||
ZodCustomStringFormat<"sha384_base64url">
|
||||
>();
|
||||
|
||||
// Test generic format types are correctly inferred and Enc defaults to "hex"
|
||||
expectTypeOf(hash("sha256")).toEqualTypeOf<ZodCustomStringFormat<"sha256_hex">>();
|
||||
|
||||
// --- Runtime matrix (success + a few sharp-edged failures per combo)
|
||||
for (const alg of algs) {
|
||||
const { hex, base64, base64url } = makeDigests(alg, input);
|
||||
|
||||
// Success cases
|
||||
expect(hash(alg).parse(hex)).toBe(hex); // default enc=hex
|
||||
expect(hash(alg, { enc: "hex" }).parse(hex)).toBe(hex);
|
||||
expect(hash(alg, { enc: "base64" }).parse(base64)).toBe(base64);
|
||||
expect(hash(alg, { enc: "base64url" }).parse(base64url)).toBe(base64url);
|
||||
|
||||
// Failure cases (wrong encoding to schema)
|
||||
expect(() => hash(alg, { enc: "hex" }).parse(base64)).toThrow();
|
||||
expect(() => hash(alg, { enc: "base64" }).parse(hex)).toThrow();
|
||||
expect(() => hash(alg, { enc: "base64url" }).parse(base64)).toThrow();
|
||||
|
||||
// Encoding-specific failures
|
||||
// hex: uppercase allowed, wrong length should fail
|
||||
hash(alg, { enc: "hex" }).parse(hex.toUpperCase());
|
||||
expect(() => hash(alg, { enc: "hex" }).parse(hex.slice(0, -1))).toThrow();
|
||||
|
||||
// base64: missing required padding should fail (only for algorithms that require padding)
|
||||
if (base64.includes("=")) {
|
||||
const base64NoPad = base64.replace(/=+$/g, "");
|
||||
expect(() => hash(alg, { enc: "base64" }).parse(base64NoPad)).toThrow();
|
||||
}
|
||||
|
||||
// base64url: adding padding or using invalid characters should fail
|
||||
expect(() => hash(alg, { enc: "base64url" }).parse(base64url + "=")).toThrow();
|
||||
expect(() => hash(alg, { enc: "base64url" }).parse(base64url + "!")).toThrow();
|
||||
|
||||
// Param object present but enc omitted should still default to hex at runtime
|
||||
const schemaWithEmptyParams = hash(alg, {} as any);
|
||||
expect(schemaWithEmptyParams.parse(hex)).toBe(hex);
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,51 @@
|
||||
/**
|
||||
* @fileoverview Rule to flag comparisons to null without a type-checking
|
||||
* operator.
|
||||
* @author Ian Christian Myers
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Disallow `null` comparisons without type-checking operators",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-eq-null",
|
||||
},
|
||||
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
unexpected: "Use '===' to compare with null.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
return {
|
||||
BinaryExpression(node) {
|
||||
const badOperator =
|
||||
node.operator === "==" || node.operator === "!=";
|
||||
|
||||
if (
|
||||
(node.right.type === "Literal" &&
|
||||
node.right.raw === "null" &&
|
||||
badOperator) ||
|
||||
(node.left.type === "Literal" &&
|
||||
node.left.raw === "null" &&
|
||||
badOperator)
|
||||
) {
|
||||
context.report({ node, messageId: "unexpected" });
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,33 @@
|
||||
'use strict';
|
||||
|
||||
const Jayson = require('../..');
|
||||
|
||||
/**
|
||||
* Namespace available as require('jayson/promise')
|
||||
* @namespace JaysonPromise
|
||||
*/
|
||||
const JaysonPromise = module.exports;
|
||||
|
||||
/**
|
||||
* @static
|
||||
* @type PromiseClient
|
||||
*/
|
||||
JaysonPromise.Client = JaysonPromise.client = require('./client');
|
||||
|
||||
/**
|
||||
* @static
|
||||
* @type Server
|
||||
*/
|
||||
JaysonPromise.Server = JaysonPromise.server = require('./server');
|
||||
|
||||
/**
|
||||
* @static
|
||||
* @type Utils
|
||||
*/
|
||||
JaysonPromise.Utils = JaysonPromise.utils = Jayson.utils;
|
||||
|
||||
/**
|
||||
* @static
|
||||
* @type PromiseMethod
|
||||
*/
|
||||
JaysonPromise.Method = JaysonPromise.method = require('./method');
|
||||
@@ -0,0 +1,39 @@
|
||||
import { type ClientOptions, type ClientSocketOptions, type ClientSpawnOptions } from "../options.ts";
|
||||
import { TimingCollector, type TimingInfo } from "../timing.ts";
|
||||
export type { ClientOptions, ClientSocketOptions, ClientSpawnOptions };
|
||||
/**
|
||||
* Client handles communication with the TypeScript API server
|
||||
* over STDIO (spawned process) or a Unix domain socket using JSON-RPC.
|
||||
*/
|
||||
export declare class Client {
|
||||
private socket;
|
||||
private process;
|
||||
private connection;
|
||||
private options;
|
||||
private connected;
|
||||
private timing;
|
||||
constructor(options: ClientOptions);
|
||||
connect(): Promise<void>;
|
||||
private connectViaSpawn;
|
||||
private connectViaSocket;
|
||||
private registerFSCallbacks;
|
||||
apiRequest<T>(method: string, params?: unknown): Promise<T>;
|
||||
apiRequestBinary(method: string, params?: unknown): Promise<Uint8Array | undefined>;
|
||||
/**
|
||||
* Returns the timing collector that per-node materialization is reported
|
||||
* into, or undefined when timing collection is disabled. The returned
|
||||
* collector is the same one folded into {@link getTimingInfo}, so
|
||||
* materialization totals surface alongside request timings.
|
||||
*/
|
||||
getTimingCollector(): TimingCollector | undefined;
|
||||
/**
|
||||
* Returns a combined timing snapshot: client-measured round-trip and byte
|
||||
* counts folded together with the server's own per-request processing time
|
||||
* (fetched via a getServerTiming request) and estimated transport overhead.
|
||||
*/
|
||||
getTimingInfo(): Promise<TimingInfo>;
|
||||
resetTimingInfo(): Promise<void>;
|
||||
private fetchServerTiming;
|
||||
close(): Promise<void>;
|
||||
}
|
||||
//# sourceMappingURL=client.d.ts.map
|
||||
@@ -0,0 +1,125 @@
|
||||
'use strict';
|
||||
|
||||
var schema = {
|
||||
additionalItems: subschema('additionalItems'),
|
||||
items: subschema('items'),
|
||||
contains: subschema('contains'),
|
||||
additionalProperties: subschema('additionalProperties'),
|
||||
propertyNames: subschema('propertyNames'),
|
||||
not: subschema('not'),
|
||||
allOf: [
|
||||
subschema('allOf_0'),
|
||||
subschema('allOf_1'),
|
||||
{
|
||||
items: [
|
||||
subschema('items_0'),
|
||||
subschema('items_1'),
|
||||
]
|
||||
}
|
||||
],
|
||||
anyOf: [
|
||||
subschema('anyOf_0'),
|
||||
subschema('anyOf_1'),
|
||||
],
|
||||
oneOf: [
|
||||
subschema('oneOf_0'),
|
||||
subschema('oneOf_1'),
|
||||
],
|
||||
definitions: {
|
||||
foo: subschema('definitions_foo'),
|
||||
bar: subschema('definitions_bar'),
|
||||
},
|
||||
properties: {
|
||||
foo: subschema('properties_foo'),
|
||||
bar: subschema('properties_bar'),
|
||||
},
|
||||
patternProperties: {
|
||||
foo: subschema('patternProperties_foo'),
|
||||
bar: subschema('patternProperties_bar'),
|
||||
},
|
||||
dependencies: {
|
||||
foo: subschema('dependencies_foo'),
|
||||
bar: subschema('dependencies_bar'),
|
||||
},
|
||||
required: ['foo', 'bar']
|
||||
};
|
||||
|
||||
|
||||
function subschema(keyword) {
|
||||
var sch = {
|
||||
properties: {},
|
||||
additionalProperties: false,
|
||||
additionalItems: false,
|
||||
anyOf: [
|
||||
{format: 'email'},
|
||||
{format: 'hostname'}
|
||||
]
|
||||
};
|
||||
sch.properties['foo_' + keyword] = {title: 'foo'};
|
||||
sch.properties['bar_' + keyword] = {title: 'bar'};
|
||||
return sch;
|
||||
}
|
||||
|
||||
|
||||
module.exports = {
|
||||
schema: schema,
|
||||
|
||||
// schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
|
||||
expectedCalls: [[schema, '', schema, undefined, undefined, undefined, undefined]]
|
||||
.concat(expectedCalls('additionalItems'))
|
||||
.concat(expectedCalls('items'))
|
||||
.concat(expectedCalls('contains'))
|
||||
.concat(expectedCalls('additionalProperties'))
|
||||
.concat(expectedCalls('propertyNames'))
|
||||
.concat(expectedCalls('not'))
|
||||
.concat(expectedCallsChild('allOf', 0))
|
||||
.concat(expectedCallsChild('allOf', 1))
|
||||
.concat([
|
||||
[schema.allOf[2], '/allOf/2', schema, '', 'allOf', schema, 2],
|
||||
[schema.allOf[2].items[0], '/allOf/2/items/0', schema, '/allOf/2', 'items', schema.allOf[2], 0],
|
||||
[schema.allOf[2].items[0].properties.foo_items_0, '/allOf/2/items/0/properties/foo_items_0', schema, '/allOf/2/items/0', 'properties', schema.allOf[2].items[0], 'foo_items_0'],
|
||||
[schema.allOf[2].items[0].properties.bar_items_0, '/allOf/2/items/0/properties/bar_items_0', schema, '/allOf/2/items/0', 'properties', schema.allOf[2].items[0], 'bar_items_0'],
|
||||
[schema.allOf[2].items[0].anyOf[0], '/allOf/2/items/0/anyOf/0', schema, '/allOf/2/items/0', 'anyOf', schema.allOf[2].items[0], 0],
|
||||
[schema.allOf[2].items[0].anyOf[1], '/allOf/2/items/0/anyOf/1', schema, '/allOf/2/items/0', 'anyOf', schema.allOf[2].items[0], 1],
|
||||
|
||||
[schema.allOf[2].items[1], '/allOf/2/items/1', schema, '/allOf/2', 'items', schema.allOf[2], 1],
|
||||
[schema.allOf[2].items[1].properties.foo_items_1, '/allOf/2/items/1/properties/foo_items_1', schema, '/allOf/2/items/1', 'properties', schema.allOf[2].items[1], 'foo_items_1'],
|
||||
[schema.allOf[2].items[1].properties.bar_items_1, '/allOf/2/items/1/properties/bar_items_1', schema, '/allOf/2/items/1', 'properties', schema.allOf[2].items[1], 'bar_items_1'],
|
||||
[schema.allOf[2].items[1].anyOf[0], '/allOf/2/items/1/anyOf/0', schema, '/allOf/2/items/1', 'anyOf', schema.allOf[2].items[1], 0],
|
||||
[schema.allOf[2].items[1].anyOf[1], '/allOf/2/items/1/anyOf/1', schema, '/allOf/2/items/1', 'anyOf', schema.allOf[2].items[1], 1]
|
||||
])
|
||||
.concat(expectedCallsChild('anyOf', 0))
|
||||
.concat(expectedCallsChild('anyOf', 1))
|
||||
.concat(expectedCallsChild('oneOf', 0))
|
||||
.concat(expectedCallsChild('oneOf', 1))
|
||||
.concat(expectedCallsChild('definitions', 'foo'))
|
||||
.concat(expectedCallsChild('definitions', 'bar'))
|
||||
.concat(expectedCallsChild('properties', 'foo'))
|
||||
.concat(expectedCallsChild('properties', 'bar'))
|
||||
.concat(expectedCallsChild('patternProperties', 'foo'))
|
||||
.concat(expectedCallsChild('patternProperties', 'bar'))
|
||||
.concat(expectedCallsChild('dependencies', 'foo'))
|
||||
.concat(expectedCallsChild('dependencies', 'bar'))
|
||||
};
|
||||
|
||||
|
||||
function expectedCalls(keyword) {
|
||||
return [
|
||||
[schema[keyword], `/${keyword}`, schema, '', keyword, schema, undefined],
|
||||
[schema[keyword].properties[`foo_${keyword}`], `/${keyword}/properties/foo_${keyword}`, schema, `/${keyword}`, 'properties', schema[keyword], `foo_${keyword}`],
|
||||
[schema[keyword].properties[`bar_${keyword}`], `/${keyword}/properties/bar_${keyword}`, schema, `/${keyword}`, 'properties', schema[keyword], `bar_${keyword}`],
|
||||
[schema[keyword].anyOf[0], `/${keyword}/anyOf/0`, schema, `/${keyword}`, 'anyOf', schema[keyword], 0],
|
||||
[schema[keyword].anyOf[1], `/${keyword}/anyOf/1`, schema, `/${keyword}`, 'anyOf', schema[keyword], 1]
|
||||
];
|
||||
}
|
||||
|
||||
|
||||
function expectedCallsChild(keyword, i) {
|
||||
return [
|
||||
[schema[keyword][i], `/${keyword}/${i}`, schema, '', keyword, schema, i],
|
||||
[schema[keyword][i].properties[`foo_${keyword}_${i}`], `/${keyword}/${i}/properties/foo_${keyword}_${i}`, schema, `/${keyword}/${i}`, 'properties', schema[keyword][i], `foo_${keyword}_${i}`],
|
||||
[schema[keyword][i].properties[`bar_${keyword}_${i}`], `/${keyword}/${i}/properties/bar_${keyword}_${i}`, schema, `/${keyword}/${i}`, 'properties', schema[keyword][i], `bar_${keyword}_${i}`],
|
||||
[schema[keyword][i].anyOf[0], `/${keyword}/${i}/anyOf/0`, schema, `/${keyword}/${i}`, 'anyOf', schema[keyword][i], 0],
|
||||
[schema[keyword][i].anyOf[1], `/${keyword}/${i}/anyOf/1`, schema, `/${keyword}/${i}`, 'anyOf', schema[keyword][i], 1]
|
||||
];
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"p384.d.ts","sourceRoot":"","sources":["src/p384.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sEAAsE;AACtE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAe,IAAI,IAAI,KAAK,EAAE,MAAM,WAAW,CAAC;AACvD,sEAAsE;AACtE,eAAO,MAAM,IAAI,EAAE,OAAO,KAAa,CAAC;AACxC,sEAAsE;AACtE,eAAO,MAAM,SAAS,EAAE,OAAO,KAAa,CAAC;AAC7C,6EAA6E;AAC7E,eAAO,MAAM,WAAW,EAAE,SAAS,CAAC,MAAM,CAAqD,CAAC;AAChG,6EAA6E;AAC7E,eAAO,MAAM,aAAa,EAAE,SAAS,CAAC,MAAM,CAAuD,CAAC"}
|
||||
@@ -0,0 +1,14 @@
|
||||
'use strict'
|
||||
|
||||
const { Writable } = require('stream')
|
||||
|
||||
async function run (opts) {
|
||||
const stream = new Writable({
|
||||
write (chunk, enc, cb) {
|
||||
cb(new Error('kaboom'))
|
||||
}
|
||||
})
|
||||
return stream
|
||||
}
|
||||
|
||||
module.exports = run
|
||||
@@ -0,0 +1,28 @@
|
||||
function ownKeys(object, enumerableOnly) {
|
||||
var keys = Object.keys(object);
|
||||
|
||||
if (Object.getOwnPropertySymbols) {
|
||||
var symbols = Object.getOwnPropertySymbols(object);
|
||||
if (enumerableOnly) {
|
||||
symbols = symbols.filter(function(sym) {
|
||||
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
|
||||
});
|
||||
}
|
||||
keys.push.apply(keys, symbols);
|
||||
}
|
||||
|
||||
return keys;
|
||||
}
|
||||
function _object_spread_props(target, source) {
|
||||
source = source != null ? source : {};
|
||||
|
||||
if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
|
||||
else {
|
||||
ownKeys(Object(source)).forEach(function(key) {
|
||||
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
|
||||
});
|
||||
}
|
||||
|
||||
return target;
|
||||
}
|
||||
export { _object_spread_props as _ };
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,406 @@
|
||||
/**
|
||||
* @fileoverview Look for useless escapes in strings and regexes
|
||||
* @author Onur Temizkan
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
|
||||
|
||||
/**
|
||||
* @typedef {import('@eslint-community/regexpp').AST.CharacterClass} CharacterClass
|
||||
* @typedef {import('@eslint-community/regexpp').AST.ExpressionCharacterClass} ExpressionCharacterClass
|
||||
*/
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Returns the union of two sets.
|
||||
* @param {Set} setA The first set
|
||||
* @param {Set} setB The second set
|
||||
* @returns {Set} The union of the two sets
|
||||
*/
|
||||
function union(setA, setB) {
|
||||
return new Set(
|
||||
(function* () {
|
||||
yield* setA;
|
||||
yield* setB;
|
||||
})(),
|
||||
);
|
||||
}
|
||||
|
||||
const VALID_STRING_ESCAPES = union(new Set("\\nrvtbfux"), astUtils.LINEBREAKS);
|
||||
const REGEX_GENERAL_ESCAPES = new Set("\\bcdDfnpPrsStvwWxu0123456789]");
|
||||
const REGEX_NON_CHARCLASS_ESCAPES = union(
|
||||
REGEX_GENERAL_ESCAPES,
|
||||
new Set("^/.$*+?[{}|()Bk"),
|
||||
);
|
||||
|
||||
/*
|
||||
* Set of characters that require escaping in character classes in `unicodeSets` mode.
|
||||
* ( ) [ ] { } / - \ | are ClassSetSyntaxCharacter
|
||||
*/
|
||||
const REGEX_CLASSSET_CHARACTER_ESCAPES = union(
|
||||
REGEX_GENERAL_ESCAPES,
|
||||
new Set("q/[{}|()-"),
|
||||
);
|
||||
|
||||
/*
|
||||
* A single character set of ClassSetReservedDoublePunctuator.
|
||||
* && !! ## $$ %% ** ++ ,, .. :: ;; << == >> ?? @@ ^^ `` ~~ are ClassSetReservedDoublePunctuator
|
||||
*/
|
||||
const REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR = new Set(
|
||||
"!#$%&*+,.:;<=>?@^`~",
|
||||
);
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
defaultOptions: [
|
||||
{
|
||||
allowRegexCharacters: [],
|
||||
},
|
||||
],
|
||||
|
||||
docs: {
|
||||
description: "Disallow unnecessary escape characters",
|
||||
recommended: true,
|
||||
url: "https://eslint.org/docs/latest/rules/no-useless-escape",
|
||||
},
|
||||
|
||||
hasSuggestions: true,
|
||||
|
||||
messages: {
|
||||
unnecessaryEscape: "Unnecessary escape character: \\{{character}}.",
|
||||
removeEscape:
|
||||
"Remove the `\\`. This maintains the current functionality.",
|
||||
removeEscapeDoNotKeepSemantics:
|
||||
"Remove the `\\` if it was inserted by mistake.",
|
||||
escapeBackslash:
|
||||
"Replace the `\\` with `\\\\` to include the actual backslash character.",
|
||||
},
|
||||
|
||||
schema: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
allowRegexCharacters: {
|
||||
type: "array",
|
||||
items: {
|
||||
type: "string",
|
||||
},
|
||||
uniqueItems: true,
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
const [{ allowRegexCharacters }] = context.options;
|
||||
const parser = new RegExpParser();
|
||||
|
||||
/**
|
||||
* Reports a node
|
||||
* @param {ASTNode} node The node to report
|
||||
* @param {number} startOffset The backslash's offset from the start of the node
|
||||
* @param {string} character The uselessly escaped character (not including the backslash)
|
||||
* @param {boolean} [disableEscapeBackslashSuggest] `true` if escapeBackslash suggestion should be turned off.
|
||||
* @returns {void}
|
||||
*/
|
||||
function report(
|
||||
node,
|
||||
startOffset,
|
||||
character,
|
||||
disableEscapeBackslashSuggest,
|
||||
) {
|
||||
const rangeStart = node.range[0] + startOffset;
|
||||
const range = [rangeStart, rangeStart + 1];
|
||||
const start = sourceCode.getLocFromIndex(rangeStart);
|
||||
|
||||
context.report({
|
||||
node,
|
||||
loc: {
|
||||
start,
|
||||
end: { line: start.line, column: start.column + 1 },
|
||||
},
|
||||
messageId: "unnecessaryEscape",
|
||||
data: { character },
|
||||
suggest: [
|
||||
{
|
||||
// Removing unnecessary `\` characters in a directive is not guaranteed to maintain functionality.
|
||||
messageId: astUtils.isDirective(node.parent)
|
||||
? "removeEscapeDoNotKeepSemantics"
|
||||
: "removeEscape",
|
||||
fix(fixer) {
|
||||
return fixer.removeRange(range);
|
||||
},
|
||||
},
|
||||
...(disableEscapeBackslashSuggest
|
||||
? []
|
||||
: [
|
||||
{
|
||||
messageId: "escapeBackslash",
|
||||
fix(fixer) {
|
||||
return fixer.insertTextBeforeRange(
|
||||
range,
|
||||
"\\",
|
||||
);
|
||||
},
|
||||
},
|
||||
]),
|
||||
],
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the escape character in given string slice is unnecessary.
|
||||
* @private
|
||||
* @param {ASTNode} node node to validate.
|
||||
* @param {string} match string slice to validate.
|
||||
* @returns {void}
|
||||
*/
|
||||
function validateString(node, match) {
|
||||
const isTemplateElement = node.type === "TemplateElement";
|
||||
const escapedChar = match[0][1];
|
||||
let isUnnecessaryEscape = !VALID_STRING_ESCAPES.has(escapedChar);
|
||||
let isQuoteEscape;
|
||||
|
||||
if (isTemplateElement) {
|
||||
isQuoteEscape = escapedChar === "`";
|
||||
|
||||
if (escapedChar === "$") {
|
||||
// Warn if `\$` is not followed by `{`
|
||||
isUnnecessaryEscape = match.input[match.index + 2] !== "{";
|
||||
} else if (escapedChar === "{") {
|
||||
/*
|
||||
* Warn if `\{` is not preceded by `$`. If preceded by `$`, escaping
|
||||
* is necessary and the rule should not warn. If preceded by `/$`, the rule
|
||||
* will warn for the `/$` instead, as it is the first unnecessarily escaped character.
|
||||
*/
|
||||
isUnnecessaryEscape = match.input[match.index - 1] !== "$";
|
||||
}
|
||||
} else {
|
||||
isQuoteEscape = escapedChar === node.raw[0];
|
||||
}
|
||||
|
||||
if (isUnnecessaryEscape && !isQuoteEscape) {
|
||||
report(node, match.index, match[0].slice(1));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the escape character in given regexp is unnecessary.
|
||||
* @private
|
||||
* @param {ASTNode} node node to validate.
|
||||
* @returns {void}
|
||||
*/
|
||||
function validateRegExp(node) {
|
||||
const { pattern, flags } = node.regex;
|
||||
let patternNode;
|
||||
const unicode = flags.includes("u");
|
||||
const unicodeSets = flags.includes("v");
|
||||
|
||||
try {
|
||||
patternNode = parser.parsePattern(pattern, 0, pattern.length, {
|
||||
unicode,
|
||||
unicodeSets,
|
||||
});
|
||||
} catch {
|
||||
// Ignore regular expressions with syntax errors
|
||||
return;
|
||||
}
|
||||
|
||||
/** @type {(CharacterClass | ExpressionCharacterClass)[]} */
|
||||
const characterClassStack = [];
|
||||
|
||||
visitRegExpAST(patternNode, {
|
||||
onCharacterClassEnter: characterClassNode =>
|
||||
characterClassStack.unshift(characterClassNode),
|
||||
onCharacterClassLeave: () => characterClassStack.shift(),
|
||||
onExpressionCharacterClassEnter: characterClassNode =>
|
||||
characterClassStack.unshift(characterClassNode),
|
||||
onExpressionCharacterClassLeave: () =>
|
||||
characterClassStack.shift(),
|
||||
onCharacterEnter(characterNode) {
|
||||
if (!characterNode.raw.startsWith("\\")) {
|
||||
// It's not an escaped character.
|
||||
return;
|
||||
}
|
||||
|
||||
const escapedChar = characterNode.raw.slice(1);
|
||||
|
||||
if (
|
||||
escapedChar !==
|
||||
String.fromCodePoint(characterNode.value) ||
|
||||
allowRegexCharacters.includes(escapedChar)
|
||||
) {
|
||||
// It's a valid escape.
|
||||
return;
|
||||
}
|
||||
let allowedEscapes;
|
||||
|
||||
if (characterClassStack.length) {
|
||||
allowedEscapes = unicodeSets
|
||||
? REGEX_CLASSSET_CHARACTER_ESCAPES
|
||||
: REGEX_GENERAL_ESCAPES;
|
||||
} else {
|
||||
allowedEscapes = REGEX_NON_CHARCLASS_ESCAPES;
|
||||
}
|
||||
if (allowedEscapes.has(escapedChar)) {
|
||||
return;
|
||||
}
|
||||
|
||||
const reportedIndex = characterNode.start + 1;
|
||||
let disableEscapeBackslashSuggest = false;
|
||||
|
||||
if (characterClassStack.length) {
|
||||
const characterClassNode = characterClassStack[0];
|
||||
|
||||
if (escapedChar === "^") {
|
||||
/*
|
||||
* The '^' character is also a special case; it must always be escaped outside of character classes, but
|
||||
* it only needs to be escaped in character classes if it's at the beginning of the character class. To
|
||||
* account for this, consider it to be a valid escape character outside of character classes, and filter
|
||||
* out '^' characters that appear at the start of a character class.
|
||||
*/
|
||||
if (
|
||||
characterClassNode.start + 1 ===
|
||||
characterNode.start
|
||||
) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (!unicodeSets) {
|
||||
if (escapedChar === "-") {
|
||||
/*
|
||||
* The '-' character is a special case, because it's only valid to escape it if it's in a character
|
||||
* class, and is not at either edge of the character class. To account for this, don't consider '-'
|
||||
* characters to be valid in general, and filter out '-' characters that appear in the middle of a
|
||||
* character class.
|
||||
*/
|
||||
if (
|
||||
characterClassNode.start + 1 !==
|
||||
characterNode.start &&
|
||||
characterNode.end !==
|
||||
characterClassNode.end - 1
|
||||
) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// unicodeSets mode
|
||||
if (
|
||||
REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR.has(
|
||||
escapedChar,
|
||||
)
|
||||
) {
|
||||
// Escaping is valid if it is a ClassSetReservedDoublePunctuator.
|
||||
if (
|
||||
pattern[characterNode.end] === escapedChar
|
||||
) {
|
||||
return;
|
||||
}
|
||||
if (
|
||||
pattern[characterNode.start - 1] ===
|
||||
escapedChar
|
||||
) {
|
||||
if (escapedChar !== "^") {
|
||||
return;
|
||||
}
|
||||
|
||||
// If the previous character is a `negate` caret(`^`), escape to caret is unnecessary.
|
||||
|
||||
if (!characterClassNode.negate) {
|
||||
return;
|
||||
}
|
||||
const negateCaretIndex =
|
||||
characterClassNode.start + 1;
|
||||
|
||||
if (
|
||||
negateCaretIndex <
|
||||
characterNode.start - 1
|
||||
) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
characterNode.parent.type ===
|
||||
"ClassIntersection" ||
|
||||
characterNode.parent.type === "ClassSubtraction"
|
||||
) {
|
||||
disableEscapeBackslashSuggest = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
report(
|
||||
node,
|
||||
reportedIndex,
|
||||
escapedChar,
|
||||
disableEscapeBackslashSuggest,
|
||||
);
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if a node has an escape.
|
||||
* @param {ASTNode} node node to check.
|
||||
* @returns {void}
|
||||
*/
|
||||
function check(node) {
|
||||
const isTemplateElement = node.type === "TemplateElement";
|
||||
|
||||
if (
|
||||
isTemplateElement &&
|
||||
node.parent &&
|
||||
node.parent.parent &&
|
||||
node.parent.parent.type === "TaggedTemplateExpression" &&
|
||||
node.parent === node.parent.parent.quasi
|
||||
) {
|
||||
// Don't report tagged template literals, because the backslash character is accessible to the tag function.
|
||||
return;
|
||||
}
|
||||
|
||||
if (typeof node.value === "string" || isTemplateElement) {
|
||||
/*
|
||||
* JSXAttribute doesn't have any escape sequence: https://facebook.github.io/jsx/.
|
||||
* In addition, backticks are not supported by JSX yet: https://github.com/facebook/jsx/issues/25.
|
||||
*/
|
||||
if (
|
||||
node.parent.type === "JSXAttribute" ||
|
||||
node.parent.type === "JSXElement" ||
|
||||
node.parent.type === "JSXFragment"
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
const value = isTemplateElement
|
||||
? sourceCode.getText(node)
|
||||
: node.raw;
|
||||
const pattern = /\\\D/gu;
|
||||
let match;
|
||||
|
||||
while ((match = pattern.exec(value))) {
|
||||
validateString(node, match);
|
||||
}
|
||||
} else if (node.regex) {
|
||||
validateRegExp(node);
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
Literal: check,
|
||||
TemplateElement: check,
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,5 @@
|
||||
import type { TSESLint } from '@typescript-eslint/utils';
|
||||
declare const _default: TSESLint.RuleModule<"preferIncludes" | "preferStringIncludes", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
export default _default;
|
||||
@@ -0,0 +1,292 @@
|
||||
/**
|
||||
* @fileoverview Rule to disallow whitespace that is not a tab or space, whitespace inside strings and comments are allowed
|
||||
* @author Jonathan Kingston
|
||||
* @author Christophe Porteneuve
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Constants
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const ALL_IRREGULARS =
|
||||
/[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]/u;
|
||||
const IRREGULAR_WHITESPACE =
|
||||
/[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/gu;
|
||||
const IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/gu;
|
||||
const LINE_BREAK = astUtils.createGlobalLinebreakMatcher();
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "problem",
|
||||
|
||||
defaultOptions: [
|
||||
{
|
||||
skipComments: false,
|
||||
skipJSXText: false,
|
||||
skipRegExps: false,
|
||||
skipStrings: true,
|
||||
skipTemplates: false,
|
||||
},
|
||||
],
|
||||
|
||||
docs: {
|
||||
description: "Disallow irregular whitespace",
|
||||
recommended: true,
|
||||
url: "https://eslint.org/docs/latest/rules/no-irregular-whitespace",
|
||||
},
|
||||
|
||||
schema: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
skipComments: {
|
||||
type: "boolean",
|
||||
},
|
||||
skipStrings: {
|
||||
type: "boolean",
|
||||
},
|
||||
skipTemplates: {
|
||||
type: "boolean",
|
||||
},
|
||||
skipRegExps: {
|
||||
type: "boolean",
|
||||
},
|
||||
skipJSXText: {
|
||||
type: "boolean",
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
|
||||
messages: {
|
||||
noIrregularWhitespace: "Irregular whitespace not allowed.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const [
|
||||
{
|
||||
skipComments,
|
||||
skipStrings,
|
||||
skipRegExps,
|
||||
skipTemplates,
|
||||
skipJSXText,
|
||||
},
|
||||
] = context.options;
|
||||
|
||||
const sourceCode = context.sourceCode;
|
||||
const commentNodes = sourceCode.getAllComments();
|
||||
|
||||
// Module store of errors that we have found
|
||||
let errors = [];
|
||||
|
||||
/**
|
||||
* Removes errors that occur inside the given node
|
||||
* @param {ASTNode} node to check for matching errors.
|
||||
* @returns {void}
|
||||
* @private
|
||||
*/
|
||||
function removeWhitespaceError(node) {
|
||||
const locStart = node.loc.start;
|
||||
const locEnd = node.loc.end;
|
||||
|
||||
errors = errors.filter(
|
||||
({ loc: { start: errorLocStart } }) =>
|
||||
errorLocStart.line < locStart.line ||
|
||||
(errorLocStart.line === locStart.line &&
|
||||
errorLocStart.column < locStart.column) ||
|
||||
(errorLocStart.line === locEnd.line &&
|
||||
errorLocStart.column >= locEnd.column) ||
|
||||
errorLocStart.line > locEnd.line,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
|
||||
* @param {ASTNode} node to check for matching errors.
|
||||
* @returns {void}
|
||||
* @private
|
||||
*/
|
||||
function removeInvalidNodeErrorsInLiteral(node) {
|
||||
const shouldCheckStrings =
|
||||
skipStrings && typeof node.value === "string";
|
||||
const shouldCheckRegExps = skipRegExps && Boolean(node.regex);
|
||||
|
||||
if (shouldCheckStrings || shouldCheckRegExps) {
|
||||
// If we have irregular characters remove them from the errors list
|
||||
if (ALL_IRREGULARS.test(node.raw)) {
|
||||
removeWhitespaceError(node);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks template string literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
|
||||
* @param {ASTNode} node to check for matching errors.
|
||||
* @returns {void}
|
||||
* @private
|
||||
*/
|
||||
function removeInvalidNodeErrorsInTemplateLiteral(node) {
|
||||
if (typeof node.value.raw === "string") {
|
||||
if (ALL_IRREGULARS.test(node.value.raw)) {
|
||||
removeWhitespaceError(node);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks comment nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
|
||||
* @param {ASTNode} node to check for matching errors.
|
||||
* @returns {void}
|
||||
* @private
|
||||
*/
|
||||
function removeInvalidNodeErrorsInComment(node) {
|
||||
if (ALL_IRREGULARS.test(node.value)) {
|
||||
removeWhitespaceError(node);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks JSX nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
|
||||
* @param {ASTNode} node to check for matching errors.
|
||||
* @returns {void}
|
||||
* @private
|
||||
*/
|
||||
function removeInvalidNodeErrorsInJSXText(node) {
|
||||
if (ALL_IRREGULARS.test(node.raw)) {
|
||||
removeWhitespaceError(node);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks the program source for irregular whitespace
|
||||
* @param {ASTNode} node The program node
|
||||
* @returns {void}
|
||||
* @private
|
||||
*/
|
||||
function checkForIrregularWhitespace(node) {
|
||||
const sourceLines = sourceCode.lines;
|
||||
|
||||
sourceLines.forEach((sourceLine, lineIndex) => {
|
||||
const lineNumber = lineIndex + 1;
|
||||
let match;
|
||||
|
||||
while (
|
||||
(match = IRREGULAR_WHITESPACE.exec(sourceLine)) !== null
|
||||
) {
|
||||
errors.push({
|
||||
node,
|
||||
messageId: "noIrregularWhitespace",
|
||||
loc: {
|
||||
start: {
|
||||
line: lineNumber,
|
||||
column: match.index,
|
||||
},
|
||||
end: {
|
||||
line: lineNumber,
|
||||
column: match.index + match[0].length,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks the program source for irregular line terminators
|
||||
* @param {ASTNode} node The program node
|
||||
* @returns {void}
|
||||
* @private
|
||||
*/
|
||||
function checkForIrregularLineTerminators(node) {
|
||||
const source = sourceCode.getText(),
|
||||
sourceLines = sourceCode.lines,
|
||||
linebreaks = source.match(LINE_BREAK);
|
||||
let lastLineIndex = -1,
|
||||
match;
|
||||
|
||||
while ((match = IRREGULAR_LINE_TERMINATORS.exec(source)) !== null) {
|
||||
const lineIndex =
|
||||
linebreaks.indexOf(match[0], lastLineIndex + 1) || 0;
|
||||
|
||||
errors.push({
|
||||
node,
|
||||
messageId: "noIrregularWhitespace",
|
||||
loc: {
|
||||
start: {
|
||||
line: lineIndex + 1,
|
||||
column: sourceLines[lineIndex].length,
|
||||
},
|
||||
end: {
|
||||
line: lineIndex + 2,
|
||||
column: 0,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
lastLineIndex = lineIndex;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A no-op function to act as placeholder for comment accumulation when the `skipComments` option is `false`.
|
||||
* @returns {void}
|
||||
* @private
|
||||
*/
|
||||
function noop() {}
|
||||
|
||||
const nodes = {};
|
||||
|
||||
if (ALL_IRREGULARS.test(sourceCode.getText())) {
|
||||
nodes.Program = function (node) {
|
||||
/*
|
||||
* As we can easily fire warnings for all white space issues with
|
||||
* all the source its simpler to fire them here.
|
||||
* This means we can check all the application code without having
|
||||
* to worry about issues caused in the parser tokens.
|
||||
* When writing this code also evaluating per node was missing out
|
||||
* connecting tokens in some cases.
|
||||
* We can later filter the errors when they are found to be not an
|
||||
* issue in nodes we don't care about.
|
||||
*/
|
||||
checkForIrregularWhitespace(node);
|
||||
checkForIrregularLineTerminators(node);
|
||||
};
|
||||
|
||||
nodes.Literal = removeInvalidNodeErrorsInLiteral;
|
||||
nodes.TemplateElement = skipTemplates
|
||||
? removeInvalidNodeErrorsInTemplateLiteral
|
||||
: noop;
|
||||
nodes.JSXText = skipJSXText
|
||||
? removeInvalidNodeErrorsInJSXText
|
||||
: noop;
|
||||
nodes["Program:exit"] = function () {
|
||||
if (skipComments) {
|
||||
// First strip errors occurring in comment nodes.
|
||||
commentNodes.forEach(removeInvalidNodeErrorsInComment);
|
||||
}
|
||||
|
||||
// If we have any errors remaining report on them
|
||||
errors.forEach(error => context.report(error));
|
||||
};
|
||||
} else {
|
||||
nodes.Program = noop;
|
||||
}
|
||||
|
||||
return nodes;
|
||||
},
|
||||
};
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,229 @@
|
||||
# Changelog
|
||||
|
||||
All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
|
||||
|
||||
### [8.3.2](https://github.com/uuidjs/uuid/compare/v8.3.1...v8.3.2) (2020-12-08)
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- lazy load getRandomValues ([#537](https://github.com/uuidjs/uuid/issues/537)) ([16c8f6d](https://github.com/uuidjs/uuid/commit/16c8f6df2f6b09b4d6235602d6a591188320a82e)), closes [#536](https://github.com/uuidjs/uuid/issues/536)
|
||||
|
||||
### [8.3.1](https://github.com/uuidjs/uuid/compare/v8.3.0...v8.3.1) (2020-10-04)
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- support expo>=39.0.0 ([#515](https://github.com/uuidjs/uuid/issues/515)) ([c65a0f3](https://github.com/uuidjs/uuid/commit/c65a0f3fa73b901959d638d1e3591dfacdbed867)), closes [#375](https://github.com/uuidjs/uuid/issues/375)
|
||||
|
||||
## [8.3.0](https://github.com/uuidjs/uuid/compare/v8.2.0...v8.3.0) (2020-07-27)
|
||||
|
||||
### Features
|
||||
|
||||
- add parse/stringify/validate/version/NIL APIs ([#479](https://github.com/uuidjs/uuid/issues/479)) ([0e6c10b](https://github.com/uuidjs/uuid/commit/0e6c10ba1bf9517796ff23c052fc0468eedfd5f4)), closes [#475](https://github.com/uuidjs/uuid/issues/475) [#478](https://github.com/uuidjs/uuid/issues/478) [#480](https://github.com/uuidjs/uuid/issues/480) [#481](https://github.com/uuidjs/uuid/issues/481) [#180](https://github.com/uuidjs/uuid/issues/180)
|
||||
|
||||
## [8.2.0](https://github.com/uuidjs/uuid/compare/v8.1.0...v8.2.0) (2020-06-23)
|
||||
|
||||
### Features
|
||||
|
||||
- improve performance of v1 string representation ([#453](https://github.com/uuidjs/uuid/issues/453)) ([0ee0b67](https://github.com/uuidjs/uuid/commit/0ee0b67c37846529c66089880414d29f3ae132d5))
|
||||
- remove deprecated v4 string parameter ([#454](https://github.com/uuidjs/uuid/issues/454)) ([88ce3ca](https://github.com/uuidjs/uuid/commit/88ce3ca0ba046f60856de62c7ce03f7ba98ba46c)), closes [#437](https://github.com/uuidjs/uuid/issues/437)
|
||||
- support jspm ([#473](https://github.com/uuidjs/uuid/issues/473)) ([e9f2587](https://github.com/uuidjs/uuid/commit/e9f2587a92575cac31bc1d4ae944e17c09756659))
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- prepare package exports for webpack 5 ([#468](https://github.com/uuidjs/uuid/issues/468)) ([8d6e6a5](https://github.com/uuidjs/uuid/commit/8d6e6a5f8965ca9575eb4d92e99a43435f4a58a8))
|
||||
|
||||
## [8.1.0](https://github.com/uuidjs/uuid/compare/v8.0.0...v8.1.0) (2020-05-20)
|
||||
|
||||
### Features
|
||||
|
||||
- improve v4 performance by reusing random number array ([#435](https://github.com/uuidjs/uuid/issues/435)) ([bf4af0d](https://github.com/uuidjs/uuid/commit/bf4af0d711b4d2ed03d1f74fd12ad0baa87dc79d))
|
||||
- optimize V8 performance of bytesToUuid ([#434](https://github.com/uuidjs/uuid/issues/434)) ([e156415](https://github.com/uuidjs/uuid/commit/e156415448ec1af2351fa0b6660cfb22581971f2))
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- export package.json required by react-native and bundlers ([#449](https://github.com/uuidjs/uuid/issues/449)) ([be1c8fe](https://github.com/uuidjs/uuid/commit/be1c8fe9a3206c358e0059b52fafd7213aa48a52)), closes [ai/nanoevents#44](https://github.com/ai/nanoevents/issues/44#issuecomment-602010343) [#444](https://github.com/uuidjs/uuid/issues/444)
|
||||
|
||||
## [8.0.0](https://github.com/uuidjs/uuid/compare/v7.0.3...v8.0.0) (2020-04-29)
|
||||
|
||||
### ⚠ BREAKING CHANGES
|
||||
|
||||
- For native ECMAScript Module (ESM) usage in Node.js only named exports are exposed, there is no more default export.
|
||||
|
||||
```diff
|
||||
-import uuid from 'uuid';
|
||||
-console.log(uuid.v4()); // -> 'cd6c3b08-0adc-4f4b-a6ef-36087a1c9869'
|
||||
+import { v4 as uuidv4 } from 'uuid';
|
||||
+uuidv4(); // ⇨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'
|
||||
```
|
||||
|
||||
- Deep requiring specific algorithms of this library like `require('uuid/v4')`, which has been deprecated in `uuid@7`, is no longer supported.
|
||||
|
||||
Instead use the named exports that this module exports.
|
||||
|
||||
For ECMAScript Modules (ESM):
|
||||
|
||||
```diff
|
||||
-import uuidv4 from 'uuid/v4';
|
||||
+import { v4 as uuidv4 } from 'uuid';
|
||||
uuidv4();
|
||||
```
|
||||
|
||||
For CommonJS:
|
||||
|
||||
```diff
|
||||
-const uuidv4 = require('uuid/v4');
|
||||
+const { v4: uuidv4 } = require('uuid');
|
||||
uuidv4();
|
||||
```
|
||||
|
||||
### Features
|
||||
|
||||
- native Node.js ES Modules (wrapper approach) ([#423](https://github.com/uuidjs/uuid/issues/423)) ([2d9f590](https://github.com/uuidjs/uuid/commit/2d9f590ad9701d692625c07ed62f0a0f91227991)), closes [#245](https://github.com/uuidjs/uuid/issues/245) [#419](https://github.com/uuidjs/uuid/issues/419) [#342](https://github.com/uuidjs/uuid/issues/342)
|
||||
- remove deep requires ([#426](https://github.com/uuidjs/uuid/issues/426)) ([daf72b8](https://github.com/uuidjs/uuid/commit/daf72b84ceb20272a81bb5fbddb05dd95922cbba))
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- add CommonJS syntax example to README quickstart section ([#417](https://github.com/uuidjs/uuid/issues/417)) ([e0ec840](https://github.com/uuidjs/uuid/commit/e0ec8402c7ad44b7ef0453036c612f5db513fda0))
|
||||
|
||||
### [7.0.3](https://github.com/uuidjs/uuid/compare/v7.0.2...v7.0.3) (2020-03-31)
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- make deep require deprecation warning work in browsers ([#409](https://github.com/uuidjs/uuid/issues/409)) ([4b71107](https://github.com/uuidjs/uuid/commit/4b71107d8c0d2ef56861ede6403fc9dc35a1e6bf)), closes [#408](https://github.com/uuidjs/uuid/issues/408)
|
||||
|
||||
### [7.0.2](https://github.com/uuidjs/uuid/compare/v7.0.1...v7.0.2) (2020-03-04)
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- make access to msCrypto consistent ([#393](https://github.com/uuidjs/uuid/issues/393)) ([8bf2a20](https://github.com/uuidjs/uuid/commit/8bf2a20f3565df743da7215eebdbada9d2df118c))
|
||||
- simplify link in deprecation warning ([#391](https://github.com/uuidjs/uuid/issues/391)) ([bb2c8e4](https://github.com/uuidjs/uuid/commit/bb2c8e4e9f4c5f9c1eaaf3ea59710c633cd90cb7))
|
||||
- update links to match content in readme ([#386](https://github.com/uuidjs/uuid/issues/386)) ([44f2f86](https://github.com/uuidjs/uuid/commit/44f2f86e9d2bbf14ee5f0f00f72a3db1292666d4))
|
||||
|
||||
### [7.0.1](https://github.com/uuidjs/uuid/compare/v7.0.0...v7.0.1) (2020-02-25)
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- clean up esm builds for node and browser ([#383](https://github.com/uuidjs/uuid/issues/383)) ([59e6a49](https://github.com/uuidjs/uuid/commit/59e6a49e7ce7b3e8fb0f3ee52b9daae72af467dc))
|
||||
- provide browser versions independent from module system ([#380](https://github.com/uuidjs/uuid/issues/380)) ([4344a22](https://github.com/uuidjs/uuid/commit/4344a22e7aed33be8627eeaaf05360f256a21753)), closes [#378](https://github.com/uuidjs/uuid/issues/378)
|
||||
|
||||
## [7.0.0](https://github.com/uuidjs/uuid/compare/v3.4.0...v7.0.0) (2020-02-24)
|
||||
|
||||
### ⚠ BREAKING CHANGES
|
||||
|
||||
- The default export, which used to be the v4() method but which was already discouraged in v3.x of this library, has been removed.
|
||||
- Explicitly note that deep imports of the different uuid version functions are deprecated and no longer encouraged and that ECMAScript module named imports should be used instead. Emit a deprecation warning for people who deep-require the different algorithm variants.
|
||||
- Remove builtin support for insecure random number generators in the browser. Users who want that will have to supply their own random number generator function.
|
||||
- Remove support for generating v3 and v5 UUIDs in Node.js<4.x
|
||||
- Convert code base to ECMAScript Modules (ESM) and release CommonJS build for node and ESM build for browser bundlers.
|
||||
|
||||
### Features
|
||||
|
||||
- add UMD build to npm package ([#357](https://github.com/uuidjs/uuid/issues/357)) ([4e75adf](https://github.com/uuidjs/uuid/commit/4e75adf435196f28e3fbbe0185d654b5ded7ca2c)), closes [#345](https://github.com/uuidjs/uuid/issues/345)
|
||||
- add various es module and CommonJS examples ([b238510](https://github.com/uuidjs/uuid/commit/b238510bf352463521f74bab175a3af9b7a42555))
|
||||
- ensure that docs are up-to-date in CI ([ee5e77d](https://github.com/uuidjs/uuid/commit/ee5e77db547474f5a8f23d6c857a6d399209986b))
|
||||
- hybrid CommonJS & ECMAScript modules build ([a3f078f](https://github.com/uuidjs/uuid/commit/a3f078faa0baff69ab41aed08e041f8f9c8993d0))
|
||||
- remove insecure fallback random number generator ([3a5842b](https://github.com/uuidjs/uuid/commit/3a5842b141a6e5de0ae338f391661e6b84b167c9)), closes [#173](https://github.com/uuidjs/uuid/issues/173)
|
||||
- remove support for pre Node.js v4 Buffer API ([#356](https://github.com/uuidjs/uuid/issues/356)) ([b59b5c5](https://github.com/uuidjs/uuid/commit/b59b5c5ecad271c5453f1a156f011671f6d35627))
|
||||
- rename repository to github:uuidjs/uuid ([#351](https://github.com/uuidjs/uuid/issues/351)) ([c37a518](https://github.com/uuidjs/uuid/commit/c37a518e367ac4b6d0aa62dba1bc6ce9e85020f7)), closes [#338](https://github.com/uuidjs/uuid/issues/338)
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- add deep-require proxies for local testing and adjust tests ([#365](https://github.com/uuidjs/uuid/issues/365)) ([7fedc79](https://github.com/uuidjs/uuid/commit/7fedc79ac8fda4bfd1c566c7f05ef4ac13b2db48))
|
||||
- add note about removal of default export ([#372](https://github.com/uuidjs/uuid/issues/372)) ([12749b7](https://github.com/uuidjs/uuid/commit/12749b700eb49db8a9759fd306d8be05dbfbd58c)), closes [#370](https://github.com/uuidjs/uuid/issues/370)
|
||||
- deprecated deep requiring of the different algorithm versions ([#361](https://github.com/uuidjs/uuid/issues/361)) ([c0bdf15](https://github.com/uuidjs/uuid/commit/c0bdf15e417639b1aeb0b247b2fb11f7a0a26b23))
|
||||
|
||||
## [3.4.0](https://github.com/uuidjs/uuid/compare/v3.3.3...v3.4.0) (2020-01-16)
|
||||
|
||||
### Features
|
||||
|
||||
- rename repository to github:uuidjs/uuid ([#351](https://github.com/uuidjs/uuid/issues/351)) ([e2d7314](https://github.com/uuidjs/uuid/commit/e2d7314)), closes [#338](https://github.com/uuidjs/uuid/issues/338)
|
||||
|
||||
## [3.3.3](https://github.com/uuidjs/uuid/compare/v3.3.2...v3.3.3) (2019-08-19)
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- no longer run ci tests on node v4
|
||||
- upgrade dependencies
|
||||
|
||||
## [3.3.2](https://github.com/uuidjs/uuid/compare/v3.3.1...v3.3.2) (2018-06-28)
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- typo ([305d877](https://github.com/uuidjs/uuid/commit/305d877))
|
||||
|
||||
## [3.3.1](https://github.com/uuidjs/uuid/compare/v3.3.0...v3.3.1) (2018-06-28)
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- fix [#284](https://github.com/uuidjs/uuid/issues/284) by setting function name in try-catch ([f2a60f2](https://github.com/uuidjs/uuid/commit/f2a60f2))
|
||||
|
||||
# [3.3.0](https://github.com/uuidjs/uuid/compare/v3.2.1...v3.3.0) (2018-06-22)
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- assignment to readonly property to allow running in strict mode ([#270](https://github.com/uuidjs/uuid/issues/270)) ([d062fdc](https://github.com/uuidjs/uuid/commit/d062fdc))
|
||||
- fix [#229](https://github.com/uuidjs/uuid/issues/229) ([c9684d4](https://github.com/uuidjs/uuid/commit/c9684d4))
|
||||
- Get correct version of IE11 crypto ([#274](https://github.com/uuidjs/uuid/issues/274)) ([153d331](https://github.com/uuidjs/uuid/commit/153d331))
|
||||
- mem issue when generating uuid ([#267](https://github.com/uuidjs/uuid/issues/267)) ([c47702c](https://github.com/uuidjs/uuid/commit/c47702c))
|
||||
|
||||
### Features
|
||||
|
||||
- enforce Conventional Commit style commit messages ([#282](https://github.com/uuidjs/uuid/issues/282)) ([cc9a182](https://github.com/uuidjs/uuid/commit/cc9a182))
|
||||
|
||||
## [3.2.1](https://github.com/uuidjs/uuid/compare/v3.2.0...v3.2.1) (2018-01-16)
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- use msCrypto if available. Fixes [#241](https://github.com/uuidjs/uuid/issues/241) ([#247](https://github.com/uuidjs/uuid/issues/247)) ([1fef18b](https://github.com/uuidjs/uuid/commit/1fef18b))
|
||||
|
||||
# [3.2.0](https://github.com/uuidjs/uuid/compare/v3.1.0...v3.2.0) (2018-01-16)
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- remove mistakenly added typescript dependency, rollback version (standard-version will auto-increment) ([09fa824](https://github.com/uuidjs/uuid/commit/09fa824))
|
||||
- use msCrypto if available. Fixes [#241](https://github.com/uuidjs/uuid/issues/241) ([#247](https://github.com/uuidjs/uuid/issues/247)) ([1fef18b](https://github.com/uuidjs/uuid/commit/1fef18b))
|
||||
|
||||
### Features
|
||||
|
||||
- Add v3 Support ([#217](https://github.com/uuidjs/uuid/issues/217)) ([d94f726](https://github.com/uuidjs/uuid/commit/d94f726))
|
||||
|
||||
# [3.1.0](https://github.com/uuidjs/uuid/compare/v3.1.0...v3.0.1) (2017-06-17)
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
- (fix) Add .npmignore file to exclude test/ and other non-essential files from packing. (#183)
|
||||
- Fix typo (#178)
|
||||
- Simple typo fix (#165)
|
||||
|
||||
### Features
|
||||
|
||||
- v5 support in CLI (#197)
|
||||
- V5 support (#188)
|
||||
|
||||
# 3.0.1 (2016-11-28)
|
||||
|
||||
- split uuid versions into separate files
|
||||
|
||||
# 3.0.0 (2016-11-17)
|
||||
|
||||
- remove .parse and .unparse
|
||||
|
||||
# 2.0.0
|
||||
|
||||
- Removed uuid.BufferClass
|
||||
|
||||
# 1.4.0
|
||||
|
||||
- Improved module context detection
|
||||
- Removed public RNG functions
|
||||
|
||||
# 1.3.2
|
||||
|
||||
- Improve tests and handling of v1() options (Issue #24)
|
||||
- Expose RNG option to allow for perf testing with different generators
|
||||
|
||||
# 1.3.0
|
||||
|
||||
- Support for version 1 ids, thanks to [@ctavan](https://github.com/ctavan)!
|
||||
- Support for node.js crypto API
|
||||
- De-emphasizing performance in favor of a) cryptographic quality PRNGs where available and b) more manageable code
|
||||
@@ -0,0 +1,402 @@
|
||||
/******************************************************************************
|
||||
Copyright (c) Microsoft Corporation.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
||||
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||||
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
||||
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
||||
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
PERFORMANCE OF THIS SOFTWARE.
|
||||
***************************************************************************** */
|
||||
/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
|
||||
|
||||
var extendStatics = function(d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
|
||||
export function __extends(d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
}
|
||||
|
||||
export var __assign = function() {
|
||||
__assign = Object.assign || function __assign(t) {
|
||||
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
||||
s = arguments[i];
|
||||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
|
||||
}
|
||||
return t;
|
||||
}
|
||||
return __assign.apply(this, arguments);
|
||||
}
|
||||
|
||||
export function __rest(s, e) {
|
||||
var t = {};
|
||||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
|
||||
t[p] = s[p];
|
||||
if (s != null && typeof Object.getOwnPropertySymbols === "function")
|
||||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
||||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
|
||||
t[p[i]] = s[p[i]];
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
export function __decorate(decorators, target, key, desc) {
|
||||
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
||||
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
||||
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
||||
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
||||
}
|
||||
|
||||
export function __param(paramIndex, decorator) {
|
||||
return function (target, key) { decorator(target, key, paramIndex); }
|
||||
}
|
||||
|
||||
export function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
|
||||
function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
|
||||
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
|
||||
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
|
||||
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
|
||||
var _, done = false;
|
||||
for (var i = decorators.length - 1; i >= 0; i--) {
|
||||
var context = {};
|
||||
for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
|
||||
for (var p in contextIn.access) context.access[p] = contextIn.access[p];
|
||||
context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
|
||||
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
|
||||
if (kind === "accessor") {
|
||||
if (result === void 0) continue;
|
||||
if (result === null || typeof result !== "object") throw new TypeError("Object expected");
|
||||
if (_ = accept(result.get)) descriptor.get = _;
|
||||
if (_ = accept(result.set)) descriptor.set = _;
|
||||
if (_ = accept(result.init)) initializers.unshift(_);
|
||||
}
|
||||
else if (_ = accept(result)) {
|
||||
if (kind === "field") initializers.unshift(_);
|
||||
else descriptor[key] = _;
|
||||
}
|
||||
}
|
||||
if (target) Object.defineProperty(target, contextIn.name, descriptor);
|
||||
done = true;
|
||||
};
|
||||
|
||||
export function __runInitializers(thisArg, initializers, value) {
|
||||
var useValue = arguments.length > 2;
|
||||
for (var i = 0; i < initializers.length; i++) {
|
||||
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
|
||||
}
|
||||
return useValue ? value : void 0;
|
||||
};
|
||||
|
||||
export function __propKey(x) {
|
||||
return typeof x === "symbol" ? x : "".concat(x);
|
||||
};
|
||||
|
||||
export function __setFunctionName(f, name, prefix) {
|
||||
if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
|
||||
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
|
||||
};
|
||||
|
||||
export function __metadata(metadataKey, metadataValue) {
|
||||
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
|
||||
}
|
||||
|
||||
export function __awaiter(thisArg, _arguments, P, generator) {
|
||||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||||
return new (P || (P = Promise))(function (resolve, reject) {
|
||||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||||
});
|
||||
}
|
||||
|
||||
export function __generator(thisArg, body) {
|
||||
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
|
||||
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
||||
function verb(n) { return function (v) { return step([n, v]); }; }
|
||||
function step(op) {
|
||||
if (f) throw new TypeError("Generator is already executing.");
|
||||
while (g && (g = 0, op[0] && (_ = 0)), _) try {
|
||||
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
||||
if (y = 0, t) op = [op[0] & 2, t.value];
|
||||
switch (op[0]) {
|
||||
case 0: case 1: t = op; break;
|
||||
case 4: _.label++; return { value: op[1], done: false };
|
||||
case 5: _.label++; y = op[1]; op = [0]; continue;
|
||||
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
||||
default:
|
||||
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
||||
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
||||
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
||||
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
||||
if (t[2]) _.ops.pop();
|
||||
_.trys.pop(); continue;
|
||||
}
|
||||
op = body.call(thisArg, _);
|
||||
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
||||
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
||||
}
|
||||
}
|
||||
|
||||
export var __createBinding = Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
});
|
||||
|
||||
export function __exportStar(m, o) {
|
||||
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
|
||||
}
|
||||
|
||||
export function __values(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
}
|
||||
|
||||
export function __read(o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
}
|
||||
|
||||
/** @deprecated */
|
||||
export function __spread() {
|
||||
for (var ar = [], i = 0; i < arguments.length; i++)
|
||||
ar = ar.concat(__read(arguments[i]));
|
||||
return ar;
|
||||
}
|
||||
|
||||
/** @deprecated */
|
||||
export function __spreadArrays() {
|
||||
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
|
||||
for (var r = Array(s), k = 0, i = 0; i < il; i++)
|
||||
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
|
||||
r[k] = a[j];
|
||||
return r;
|
||||
}
|
||||
|
||||
export function __spreadArray(to, from, pack) {
|
||||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
||||
if (ar || !(i in from)) {
|
||||
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
||||
ar[i] = from[i];
|
||||
}
|
||||
}
|
||||
return to.concat(ar || Array.prototype.slice.call(from));
|
||||
}
|
||||
|
||||
export function __await(v) {
|
||||
return this instanceof __await ? (this.v = v, this) : new __await(v);
|
||||
}
|
||||
|
||||
export function __asyncGenerator(thisArg, _arguments, generator) {
|
||||
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||||
var g = generator.apply(thisArg, _arguments || []), i, q = [];
|
||||
return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
|
||||
function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
|
||||
function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
|
||||
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
|
||||
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
|
||||
function fulfill(value) { resume("next", value); }
|
||||
function reject(value) { resume("throw", value); }
|
||||
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
|
||||
}
|
||||
|
||||
export function __asyncDelegator(o) {
|
||||
var i, p;
|
||||
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
|
||||
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
|
||||
}
|
||||
|
||||
export function __asyncValues(o) {
|
||||
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||||
var m = o[Symbol.asyncIterator], i;
|
||||
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
|
||||
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
|
||||
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
|
||||
}
|
||||
|
||||
export function __makeTemplateObject(cooked, raw) {
|
||||
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
|
||||
return cooked;
|
||||
};
|
||||
|
||||
var __setModuleDefault = Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
};
|
||||
|
||||
var ownKeys = function(o) {
|
||||
ownKeys = Object.getOwnPropertyNames || function (o) {
|
||||
var ar = [];
|
||||
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
|
||||
return ar;
|
||||
};
|
||||
return ownKeys(o);
|
||||
};
|
||||
|
||||
export function __importStar(mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function __importDefault(mod) {
|
||||
return (mod && mod.__esModule) ? mod : { default: mod };
|
||||
}
|
||||
|
||||
export function __classPrivateFieldGet(receiver, state, kind, f) {
|
||||
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
|
||||
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
|
||||
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
|
||||
}
|
||||
|
||||
export function __classPrivateFieldSet(receiver, state, value, kind, f) {
|
||||
if (kind === "m") throw new TypeError("Private method is not writable");
|
||||
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
|
||||
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
|
||||
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
|
||||
}
|
||||
|
||||
export function __classPrivateFieldIn(state, receiver) {
|
||||
if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
|
||||
return typeof state === "function" ? receiver === state : state.has(receiver);
|
||||
}
|
||||
|
||||
export function __addDisposableResource(env, value, async) {
|
||||
if (value !== null && value !== void 0) {
|
||||
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
|
||||
var dispose, inner;
|
||||
if (async) {
|
||||
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
|
||||
dispose = value[Symbol.asyncDispose];
|
||||
}
|
||||
if (dispose === void 0) {
|
||||
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
|
||||
dispose = value[Symbol.dispose];
|
||||
if (async) inner = dispose;
|
||||
}
|
||||
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
|
||||
if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
|
||||
env.stack.push({ value: value, dispose: dispose, async: async });
|
||||
}
|
||||
else if (async) {
|
||||
env.stack.push({ async: true });
|
||||
}
|
||||
return value;
|
||||
|
||||
}
|
||||
|
||||
var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
|
||||
var e = new Error(message);
|
||||
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
|
||||
};
|
||||
|
||||
export function __disposeResources(env) {
|
||||
function fail(e) {
|
||||
env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
|
||||
env.hasError = true;
|
||||
}
|
||||
var r, s = 0;
|
||||
function next() {
|
||||
while (r = env.stack.pop()) {
|
||||
try {
|
||||
if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
|
||||
if (r.dispose) {
|
||||
var result = r.dispose.call(r.value);
|
||||
if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
|
||||
}
|
||||
else s |= 1;
|
||||
}
|
||||
catch (e) {
|
||||
fail(e);
|
||||
}
|
||||
}
|
||||
if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
|
||||
if (env.hasError) throw env.error;
|
||||
}
|
||||
return next();
|
||||
}
|
||||
|
||||
export function __rewriteRelativeImportExtension(path, preserveJsx) {
|
||||
if (typeof path === "string" && /^\.\.?\//.test(path)) {
|
||||
return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
|
||||
return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
|
||||
});
|
||||
}
|
||||
return path;
|
||||
}
|
||||
|
||||
export default {
|
||||
__extends: __extends,
|
||||
__assign: __assign,
|
||||
__rest: __rest,
|
||||
__decorate: __decorate,
|
||||
__param: __param,
|
||||
__esDecorate: __esDecorate,
|
||||
__runInitializers: __runInitializers,
|
||||
__propKey: __propKey,
|
||||
__setFunctionName: __setFunctionName,
|
||||
__metadata: __metadata,
|
||||
__awaiter: __awaiter,
|
||||
__generator: __generator,
|
||||
__createBinding: __createBinding,
|
||||
__exportStar: __exportStar,
|
||||
__values: __values,
|
||||
__read: __read,
|
||||
__spread: __spread,
|
||||
__spreadArrays: __spreadArrays,
|
||||
__spreadArray: __spreadArray,
|
||||
__await: __await,
|
||||
__asyncGenerator: __asyncGenerator,
|
||||
__asyncDelegator: __asyncDelegator,
|
||||
__asyncValues: __asyncValues,
|
||||
__makeTemplateObject: __makeTemplateObject,
|
||||
__importStar: __importStar,
|
||||
__importDefault: __importDefault,
|
||||
__classPrivateFieldGet: __classPrivateFieldGet,
|
||||
__classPrivateFieldSet: __classPrivateFieldSet,
|
||||
__classPrivateFieldIn: __classPrivateFieldIn,
|
||||
__addDisposableResource: __addDisposableResource,
|
||||
__disposeResources: __disposeResources,
|
||||
__rewriteRelativeImportExtension: __rewriteRelativeImportExtension,
|
||||
};
|
||||
@@ -0,0 +1,15 @@
|
||||
function _iterable_to_array_limit_loose(arr, i) {
|
||||
var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]);
|
||||
|
||||
if (_i == null) return;
|
||||
|
||||
var _arr = [];
|
||||
|
||||
for (_i = _i.call(arr), _step; !(_step = _i.next()).done;) {
|
||||
_arr.push(_step.value);
|
||||
if (i && _arr.length === i) break;
|
||||
}
|
||||
|
||||
return _arr;
|
||||
}
|
||||
export { _iterable_to_array_limit_loose as _ };
|
||||
@@ -0,0 +1,132 @@
|
||||
'use strict'
|
||||
const test = require('tape')
|
||||
const pino = require('../browser')
|
||||
|
||||
test('child has parent level', ({ end, same, is }) => {
|
||||
const instance = pino({
|
||||
level: 'error',
|
||||
browser: {}
|
||||
})
|
||||
|
||||
const child = instance.child({})
|
||||
|
||||
same(child.level, instance.level)
|
||||
end()
|
||||
})
|
||||
|
||||
test('child can set level at creation time', ({ end, same, is }) => {
|
||||
const instance = pino({
|
||||
level: 'error',
|
||||
browser: {}
|
||||
})
|
||||
|
||||
const child = instance.child({}, { level: 'info' }) // first bindings, then options
|
||||
|
||||
same(child.level, 'info')
|
||||
end()
|
||||
})
|
||||
|
||||
test('changing child level does not affect parent', ({ end, same, is }) => {
|
||||
const instance = pino({
|
||||
level: 'error',
|
||||
browser: {}
|
||||
})
|
||||
|
||||
const child = instance.child({})
|
||||
child.level = 'info'
|
||||
|
||||
same(instance.level, 'error')
|
||||
end()
|
||||
})
|
||||
|
||||
test('child should log, if its own level allows it', ({ end, same, is }) => {
|
||||
const expected = [
|
||||
{
|
||||
level: 30,
|
||||
msg: 'this is info'
|
||||
},
|
||||
{
|
||||
level: 40,
|
||||
msg: 'this is warn'
|
||||
},
|
||||
{
|
||||
level: 50,
|
||||
msg: 'this is an error'
|
||||
}
|
||||
]
|
||||
const instance = pino({
|
||||
level: 'error',
|
||||
browser: {
|
||||
write (actual) {
|
||||
checkLogObjects(is, same, actual, expected.shift())
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
const child = instance.child({})
|
||||
child.level = 'info'
|
||||
|
||||
child.debug('this is debug')
|
||||
child.info('this is info')
|
||||
child.warn('this is warn')
|
||||
child.error('this is an error')
|
||||
|
||||
same(expected.length, 0, 'not all messages were read')
|
||||
end()
|
||||
})
|
||||
|
||||
test('changing child log level should not affect parent log behavior', ({ end, same, is }) => {
|
||||
const expected = [
|
||||
{
|
||||
level: 50,
|
||||
msg: 'this is an error'
|
||||
},
|
||||
{
|
||||
level: 60,
|
||||
msg: 'this is fatal'
|
||||
}
|
||||
]
|
||||
const instance = pino({
|
||||
level: 'error',
|
||||
browser: {
|
||||
write (actual) {
|
||||
checkLogObjects(is, same, actual, expected.shift())
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
const child = instance.child({})
|
||||
child.level = 'info'
|
||||
|
||||
instance.warn('this is warn')
|
||||
instance.error('this is an error')
|
||||
instance.fatal('this is fatal')
|
||||
|
||||
same(expected.length, 0, 'not all messages were read')
|
||||
end()
|
||||
})
|
||||
|
||||
test('onChild callback should be called when new child is created', ({ end, pass, plan }) => {
|
||||
plan(1)
|
||||
const instance = pino({
|
||||
level: 'error',
|
||||
browser: {},
|
||||
onChild: (_child) => {
|
||||
pass('onChild callback was called')
|
||||
end()
|
||||
}
|
||||
})
|
||||
|
||||
instance.child({})
|
||||
})
|
||||
|
||||
function checkLogObjects (is, same, actual, expected) {
|
||||
is(actual.time <= Date.now(), true, 'time is greater than Date.now()')
|
||||
|
||||
const actualCopy = Object.assign({}, actual)
|
||||
const expectedCopy = Object.assign({}, expected)
|
||||
delete actualCopy.time
|
||||
delete expectedCopy.time
|
||||
|
||||
same(actualCopy, expectedCopy)
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
"use strict";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.default = default_1;
|
||||
const util = __importStar(require("../core/util.cjs"));
|
||||
const error = () => {
|
||||
const Sizable = {
|
||||
string: { unit: "caràcters", verb: "contenir" },
|
||||
file: { unit: "bytes", verb: "contenir" },
|
||||
array: { unit: "elements", verb: "contenir" },
|
||||
set: { unit: "elements", verb: "contenir" },
|
||||
};
|
||||
function getSizing(origin) {
|
||||
return Sizable[origin] ?? null;
|
||||
}
|
||||
const FormatDictionary = {
|
||||
regex: "entrada",
|
||||
email: "adreça electrònica",
|
||||
url: "URL",
|
||||
emoji: "emoji",
|
||||
uuid: "UUID",
|
||||
uuidv4: "UUIDv4",
|
||||
uuidv6: "UUIDv6",
|
||||
nanoid: "nanoid",
|
||||
guid: "GUID",
|
||||
cuid: "cuid",
|
||||
cuid2: "cuid2",
|
||||
ulid: "ULID",
|
||||
xid: "XID",
|
||||
ksuid: "KSUID",
|
||||
datetime: "data i hora ISO",
|
||||
date: "data ISO",
|
||||
time: "hora ISO",
|
||||
duration: "durada ISO",
|
||||
ipv4: "adreça IPv4",
|
||||
ipv6: "adreça IPv6",
|
||||
cidrv4: "rang IPv4",
|
||||
cidrv6: "rang IPv6",
|
||||
base64: "cadena codificada en base64",
|
||||
base64url: "cadena codificada en base64url",
|
||||
json_string: "cadena JSON",
|
||||
e164: "número E.164",
|
||||
jwt: "JWT",
|
||||
template_literal: "entrada",
|
||||
};
|
||||
const TypeDictionary = {
|
||||
nan: "NaN",
|
||||
};
|
||||
return (issue) => {
|
||||
switch (issue.code) {
|
||||
case "invalid_type": {
|
||||
const expected = TypeDictionary[issue.expected] ?? issue.expected;
|
||||
const receivedType = util.parsedType(issue.input);
|
||||
const received = TypeDictionary[receivedType] ?? receivedType;
|
||||
if (/^[A-Z]/.test(issue.expected)) {
|
||||
return `Tipus invàlid: s'esperava instanceof ${issue.expected}, s'ha rebut ${received}`;
|
||||
}
|
||||
return `Tipus invàlid: s'esperava ${expected}, s'ha rebut ${received}`;
|
||||
}
|
||||
case "invalid_value":
|
||||
if (issue.values.length === 1)
|
||||
return `Valor invàlid: s'esperava ${util.stringifyPrimitive(issue.values[0])}`;
|
||||
return `Opció invàlida: s'esperava una de ${util.joinValues(issue.values, " o ")}`;
|
||||
case "too_big": {
|
||||
const adj = issue.inclusive ? "com a màxim" : "menys de";
|
||||
const sizing = getSizing(issue.origin);
|
||||
if (sizing)
|
||||
return `Massa gran: s'esperava que ${issue.origin ?? "el valor"} contingués ${adj} ${issue.maximum.toString()} ${sizing.unit ?? "elements"}`;
|
||||
return `Massa gran: s'esperava que ${issue.origin ?? "el valor"} fos ${adj} ${issue.maximum.toString()}`;
|
||||
}
|
||||
case "too_small": {
|
||||
const adj = issue.inclusive ? "com a mínim" : "més de";
|
||||
const sizing = getSizing(issue.origin);
|
||||
if (sizing) {
|
||||
return `Massa petit: s'esperava que ${issue.origin} contingués ${adj} ${issue.minimum.toString()} ${sizing.unit}`;
|
||||
}
|
||||
return `Massa petit: s'esperava que ${issue.origin} fos ${adj} ${issue.minimum.toString()}`;
|
||||
}
|
||||
case "invalid_format": {
|
||||
const _issue = issue;
|
||||
if (_issue.format === "starts_with") {
|
||||
return `Format invàlid: ha de començar amb "${_issue.prefix}"`;
|
||||
}
|
||||
if (_issue.format === "ends_with")
|
||||
return `Format invàlid: ha d'acabar amb "${_issue.suffix}"`;
|
||||
if (_issue.format === "includes")
|
||||
return `Format invàlid: ha d'incloure "${_issue.includes}"`;
|
||||
if (_issue.format === "regex")
|
||||
return `Format invàlid: ha de coincidir amb el patró ${_issue.pattern}`;
|
||||
return `Format invàlid per a ${FormatDictionary[_issue.format] ?? issue.format}`;
|
||||
}
|
||||
case "not_multiple_of":
|
||||
return `Número invàlid: ha de ser múltiple de ${issue.divisor}`;
|
||||
case "unrecognized_keys":
|
||||
return `Clau${issue.keys.length > 1 ? "s" : ""} no reconeguda${issue.keys.length > 1 ? "s" : ""}: ${util.joinValues(issue.keys, ", ")}`;
|
||||
case "invalid_key":
|
||||
return `Clau invàlida a ${issue.origin}`;
|
||||
case "invalid_union":
|
||||
return "Entrada invàlida"; // Could also be "Tipus d'unió invàlid" but "Entrada invàlida" is more general
|
||||
case "invalid_element":
|
||||
return `Element invàlid a ${issue.origin}`;
|
||||
default:
|
||||
return `Entrada invàlida`;
|
||||
}
|
||||
};
|
||||
};
|
||||
function default_1() {
|
||||
return {
|
||||
localeError: error(),
|
||||
};
|
||||
}
|
||||
module.exports = exports.default;
|
||||
Reference in New Issue
Block a user