json-p3 2.2.1 → 2.3.0

package/dist/patch/errors.d.ts

@@ -1,11 +0,0 @@
-/**
- * Base class for all JSON Patch errors.
- */
-export declare class JSONPatchError extends Error {
-    readonly message: string;
-    constructor(message: string);
-}
-export declare class JSONPatchTestFailure extends JSONPatchError {
-    readonly message: string;
-    constructor(message: string);
-}

package/dist/patch/index.d.ts

@@ -1,11 +0,0 @@
-import { JSONValue } from "../types";
-import { OpObject } from "./patch";
-export { JSONPatch } from "./patch";
-export { JSONPatchError, JSONPatchTestFailure } from "./errors";
-export type { OpObject } from "./patch";
-/**
- * Apply the JSON Patch _patch_ to JSON-like data _value_.
- * @param ops - JSON Patch operations following RFC 6902.
- * @param value - The target JSON-like document to patch.
- */
-export declare function apply(ops: OpObject[], value: JSONValue): JSONValue;

package/dist/patch/patch.d.ts

@@ -1,161 +0,0 @@
-import { JSONPointer } from "../pointer";
-import { JSONValue } from "../types";
-export type OpObject = {
-    op: string;
-    path: string;
-    value?: JSONValue;
-    from?: string;
-};
-/**
- * A JSON Patch operation.
- */
-export interface Op {
-    /**
-     * The patch operation name.
-     */
-    name: string;
-    /**
-     * Apply the patch operation to _value_.
-     * @param value - The target JSON value.
-     */
-    apply: (value: JSONValue, index: number) => JSONValue;
-    /**
-     * A plain object representation of the patch operation.
-     */
-    toObject: () => OpObject;
-}
-/**
- * The JSON Patch _add_ operation.
- */
-export declare class OpAdd implements Op {
-    readonly path: JSONPointer;
-    readonly value: JSONValue;
-    name: string;
-    constructor(path: JSONPointer, value: JSONValue);
-    apply(value: JSONValue, index: number): JSONValue;
-    toObject(): OpObject;
-}
-/**
- * The JSON Patch _remove_ operation.
- */
-export declare class OpRemove implements Op {
-    readonly path: JSONPointer;
-    name: string;
-    constructor(path: JSONPointer);
-    apply(value: JSONValue, index: number): JSONValue;
-    toObject(): OpObject;
-}
-/**
- * The JSON Patch _replace_ operation.
- */
-export declare class OpReplace implements Op {
-    readonly path: JSONPointer;
-    readonly value: JSONValue;
-    name: string;
-    constructor(path: JSONPointer, value: JSONValue);
-    apply(value: JSONValue, index: number): JSONValue;
-    toObject(): OpObject;
-}
-/**
- * The JSON Patch _move_ operation.
- */
-export declare class OpMove implements Op {
-    readonly from: JSONPointer;
-    readonly path: JSONPointer;
-    name: string;
-    constructor(from: JSONPointer, path: JSONPointer);
-    apply(value: JSONValue, index: number): JSONValue;
-    toObject(): OpObject;
-}
-/**
- * The JSON Patch _copy_ operation.
- */
-export declare class OpCopy implements Op {
-    readonly from: JSONPointer;
-    readonly path: JSONPointer;
-    name: string;
-    constructor(from: JSONPointer, path: JSONPointer);
-    apply(value: JSONValue, index: number): JSONValue;
-    toObject(): OpObject;
-    protected deepCopy(value: JSONValue): JSONValue;
-}
-/**
- * The JSON Patch _test_ operation.
- */
-export declare class OpTest implements Op {
-    readonly path: JSONPointer;
-    readonly value: JSONValue;
-    name: string;
-    constructor(path: JSONPointer, value: JSONValue);
-    apply(value: JSONValue, index: number): JSONValue;
-    toObject(): OpObject;
-}
-/**
- *
- */
-export declare class JSONPatch {
-    private ops;
-    /**
-     *
-     * @param ops -
-     */
-    constructor(ops?: OpObject[]);
-    /**
-     * @returns an iterator over ops in this patch.
-     */
-    [Symbol.iterator](): Iterator<OpObject>;
-    /**
-     *
-     * @param path -
-     * @param value -
-     * @returns
-     */
-    add(path: string | JSONPointer, value: JSONValue): this;
-    /**
-     *
-     * @param path -
-     */
-    remove(path: string | JSONPointer): this;
-    /**
-     *
-     * @param path -
-     * @param value -
-     * @returns
-     */
-    replace(path: string | JSONPointer, value: JSONValue): this;
-    /**
-     *
-     * @param from -
-     * @param path -
-     * @returns
-     */
-    move(from: string | JSONPointer, path: string | JSONPointer): this;
-    /**
-     *
-     * @param from -
-     * @param path -
-     * @returns
-     */
-    copy(from: string | JSONPointer, path: string | JSONPointer): this;
-    /**
-     *
-     * @param path -
-     * @param value -
-     * @returns
-     */
-    test(path: string | JSONPointer, value: JSONValue): this;
-    /**
-     *
-     * @param value -
-     */
-    apply(value: JSONValue): JSONValue;
-    /**
-     *
-     * @returns
-     */
-    toArray(): OpObject[];
-    protected build(ops: OpObject[]): void;
-    protected opPointer(opObj: OpObject, key: keyof OpObject, op: string, index: number): JSONPointer;
-    protected opValue(opObj: OpObject, key: keyof OpObject, op: string, index: number): JSONValue;
-    protected ensurePointer(p: JSONPointer | string, op: string, index: number): JSONPointer;
-}

package/dist/path/environment.d.ts

@@ -1,165 +0,0 @@
-import { FilterExpression } from "./expression";
-import { FilterFunction } from "./functions/function";
-import { JSONPathNode, JSONPathNodeList } from "./node";
-import { JSONPathQuery } from "./path";
-import { Token } from "./token";
-import { JSONValue } from "../types";
-/**
- * JSONPath environment options. The defaults are in compliance with JSONPath
- * standards.
- */
-export type JSONPathEnvironmentOptions = {
-    /**
-     * Indicates if the environment should to be strict about its compliance with
-     * RFC 9535.
-     *
-     * Defaults to `true`. Setting `strict` to `false` enables non-standard
-     * features. Non-standard features are subject to change if conflicting
-     * features are included in a future JSONPath standard or draft standard, or
-     * an overwhelming consensus amongst the JSONPath community emerges that
-     * differs from this implementation.
-     */
-    strict?: boolean;
-    /**
-     * The maximum number allowed when indexing or slicing an array. Defaults to
-     * 2**53 -1.
-     */
-    maxIntIndex?: number;
-    /**
-     * The minimum number allowed when indexing or slicing an array. Defaults to
-     * -(2**53) -1.
-     */
-    minIntIndex?: number;
-    /**
-     * The maximum number of objects and/or arrays the recursive descent selector
-     * can visit before a `JSONPathRecursionLimitError` is thrown.
-     */
-    maxRecursionDepth?: number;
-    /**
-     * If `true`, enable nondeterministic ordering when iterating JSON object data.
-     *
-     * This is mainly useful for validating the JSONPath Compliance Test Suite.
-     */
-    nondeterministic?: boolean;
-    /**
-     * The pattern to use for the non-standard _keys selector_.
-     *
-     * The lexer expects the sticky bit to be set. Defaults to `/~/y`.
-     */
-    keysPattern?: RegExp;
-};
-/**
- * A configuration object from which JSONPath queries can be evaluated.
- *
- * An environment is where you'd register custom function extensions or set
- * the maximum recursion depth limit, for example.
- */
-export declare class JSONPathEnvironment {
-    /**
-     * Indicates if the environment should to be strict about its compliance with
-     * JSONPath standards.
-     *
-     * Defaults to `true`. Setting `strict` to `false` currently has no effect.
-     * If/when we add non-standard features, the environment's strictness will
-     * control their availability.
-     */
-    readonly strict: boolean;
-    /**
-     * The maximum number allowed when indexing or slicing an array. Defaults to
-     * 2**53 -1.
-     */
-    readonly maxIntIndex: number;
-    /**
-     * The minimum number allowed when indexing or slicing an array. Defaults to
-     * -(2**53) -1.
-     */
-    readonly minIntIndex: number;
-    /**
-     * The maximum number of objects and/or arrays the recursive descent selector
-     * can visit before a `JSONPathRecursionLimitError` is thrown.
-     */
-    readonly maxRecursionDepth: number;
-    /**
-     * If `true`, enable nondeterministic ordering when iterating JSON object data.
-     */
-    readonly nondeterministic: boolean;
-    /**
-     * The pattern to use for the non-standard _keys selector_.
-     */
-    readonly keysPattern: RegExp;
-    /**
-     * A map of function names to objects implementing the {@link FilterFunction}
-     * interface. You are free to set or delete custom filter functions directly.
-     */
-    functionRegister: Map<string, FilterFunction>;
-    private parser;
-    /**
-     * @param options - Environment configuration options.
-     */
-    constructor(options?: JSONPathEnvironmentOptions);
-    /**
-     * @param path - A JSONPath query to parse.
-     * @returns A new {@link JSONPathQuery} object, bound to this environment.
-     */
-    compile(path: string): JSONPathQuery;
-    /**
-     *
-     * @param path - A JSONPath query to parse and evaluate against _value_.
-     * @param value - Data to which _path_ will be applied.
-     * @returns The {@link JSONPathNodeList} resulting from applying _path_
-     * to _value_.
-     */
-    query(path: string, value: JSONValue): JSONPathNodeList;
-    /**
-     * A lazy version of {@link query} which is faster and more memory
-     * efficient when querying some large datasets.
-     *
-     * @param path - A JSONPath query to parse and evaluate against _value_.
-     * @param value - Data to which _path_ will be applied.
-     * @returns A sequence of {@link JSONPathNode} objects resulting from
-     * applying _path_ to _value_.
-     */
-    lazyQuery(path: string, value: JSONValue): IterableIterator<JSONPathNode>;
-    /**
-     * Return a {@link JSONPathNode} instance for the first object found in
-     * _value_ matching _path_.
-     *
-     * @param path - A JSONPath query.
-     * @param value - JSON-like data to which the query _path_ will be applied.
-     * @returns The first node in _value_ matching  _path_, or `undefined` if
-     * there are no matches.
-     */
-    match(path: string, value: JSONValue): JSONPathNode | undefined;
-    /**
-     * A hook for setting up the function register. You are encouraged to
-     * override this method in classes extending `JSONPathEnvironment`.
-     */
-    protected setupFilterFunctions(): void;
-    /**
-     * Check the well-typedness of a function's arguments at compile-time.
-     *
-     * This method is called by the parser when parsing function calls.
-     * It is expected to throw a {@link JSONPathTypeError} if the function's
-     * parameters are not well-typed.
-     *
-     * Override this if you want to deviate from the JSONPath Spec's function
-     * extension type system.
-     *
-     * @param token - The {@link Token} starting the function call. `Token.value`
-     * will contain the name of the function.
-     * @param args - One {@link FilterExpression} for each argument.
-     */
-    checkWellTypedness(token: Token, args: FilterExpression[]): FilterExpression[];
-    /**
-     * Return an array of key/values of the enumerable properties in _obj_.
-     *
-     * If you want to introduce some nondeterminism to iterating JSON-like
-     * objects, do it here. The wildcard selector, descendent segment and
-     * filter selector all use `this.environment.entries`.
-     *
-     * @param obj - A JSON-like object.
-     */
-    entries(obj: {
-        [key: string]: JSONValue;
-    }): Array<[string, JSONValue]>;
-}

package/dist/path/errors.d.ts

@@ -1,65 +0,0 @@
-import { Token } from "./token";
-/**
- * Base class for all JSONPath errors.
- */
-export declare class JSONPathError extends Error {
-    readonly message: string;
-    readonly token: Token;
-    constructor(message: string, token: Token);
-}
-/**
- * Error thrown due to unexpected, internal path tokenization problems.
- */
-export declare class JSONPathLexerError extends JSONPathError {
-    readonly message: string;
-    readonly token: Token;
-    constructor(message: string, token: Token);
-}
-/**
- * Error thrown due to type errors when evaluating filter expressions.
- */
-export declare class JSONPathTypeError extends JSONPathError {
-    readonly message: string;
-    readonly token: Token;
-    constructor(message: string, token: Token);
-}
-/**
- * Error thrown due to out of range indices.
- */
-export declare class JSONPathIndexError extends JSONPathError {
-    readonly message: string;
-    readonly token: Token;
-    constructor(message: string, token: Token);
-}
-/**
- * Error thrown when attempting to retrieve a filter function that has not
- * been registered.
- */
-export declare class UndefinedFilterFunctionError extends JSONPathError {
-    readonly message: string;
-    readonly token: Token;
-    constructor(message: string, token: Token);
-}
-/**
- * Error thrown due to syntax errors found during parsing a JSONPath query.
- */
-export declare class JSONPathSyntaxError extends JSONPathError {
-    readonly message: string;
-    readonly token: Token;
-    constructor(message: string, token: Token);
-}
-/**
- * Error thrown when the maximum recursion depth is reached.
- */
-export declare class JSONPathRecursionLimitError extends JSONPathError {
-    readonly message: string;
-    readonly token: Token;
-    constructor(message: string, token: Token);
-}
-/**
- * Error thrown due to invalid I-Regexp syntax.
- */
-export declare class IRegexpError extends Error {
-    readonly message: string;
-    constructor(message: string);
-}

package/dist/path/expression.d.ts

@@ -1,101 +0,0 @@
-import { JSONPathNodeList } from "./node";
-import { JSONPathQuery } from "./path";
-import { Token } from "./token";
-import { FilterContext, SerializationOptions } from "./types";
-/**
- * Base class for all filter expressions.
- */
-export declare abstract class FilterExpression {
-    readonly token: Token;
-    constructor(token: Token);
-    /**
-     * Evaluate the filter expression in the given context.
-     * @param context - Evaluation context.
-     */
-    abstract evaluate(context: FilterContext): unknown;
-    /**
-     * Return a string representation of the expression.
-     */
-    abstract toString(options?: SerializationOptions): string;
-}
-/**
- * Base class for JSONPath ValueType literals.
- */
-export declare abstract class FilterExpressionLiteral extends FilterExpression {
-}
-export declare class NullLiteral extends FilterExpressionLiteral {
-    evaluate(): null;
-    toString(): string;
-}
-export declare class BooleanLiteral extends FilterExpressionLiteral {
-    readonly token: Token;
-    readonly value: boolean;
-    constructor(token: Token, value: boolean);
-    evaluate(): boolean;
-    toString(): string;
-}
-export declare class StringLiteral extends FilterExpressionLiteral {
-    readonly token: Token;
-    readonly value: string;
-    constructor(token: Token, value: string);
-    evaluate(): string;
-    toString(): string;
-}
-export declare class NumberLiteral extends FilterExpressionLiteral {
-    readonly token: Token;
-    readonly value: number;
-    constructor(token: Token, value: number);
-    evaluate(): number;
-    toString(): string;
-}
-export declare class PrefixExpression extends FilterExpression {
-    readonly token: Token;
-    readonly operator: string;
-    readonly right: FilterExpression;
-    constructor(token: Token, operator: string, right: FilterExpression);
-    evaluate(context: FilterContext): boolean;
-    toString(options?: SerializationOptions): string;
-}
-export declare class InfixExpression extends FilterExpression {
-    readonly token: Token;
-    readonly left: FilterExpression;
-    readonly operator: string;
-    readonly right: FilterExpression;
-    readonly logical: boolean;
-    constructor(token: Token, left: FilterExpression, operator: string, right: FilterExpression);
-    evaluate(context: FilterContext): boolean;
-    toString(options?: SerializationOptions): string;
-}
-export declare class LogicalExpression extends FilterExpression {
-    readonly token: Token;
-    readonly expression: FilterExpression;
-    constructor(token: Token, expression: FilterExpression);
-    evaluate(context: FilterContext): boolean;
-    toString(options?: SerializationOptions): string;
-}
-/**
- * Base class for relative and absolute JSONPath query expressions.
- */
-export declare abstract class FilterQuery extends FilterExpression {
-    readonly token: Token;
-    readonly path: JSONPathQuery;
-    constructor(token: Token, path: JSONPathQuery);
-}
-export declare class RelativeQuery extends FilterQuery {
-    evaluate(context: FilterContext): JSONPathNodeList;
-    toString(options?: SerializationOptions): string;
-}
-export declare class RootQuery extends FilterQuery {
-    evaluate(context: FilterContext): JSONPathNodeList;
-    toString(options?: SerializationOptions): string;
-}
-export declare class FunctionExtension extends FilterExpression {
-    readonly token: Token;
-    readonly name: string;
-    readonly args: FilterExpression[];
-    constructor(token: Token, name: string, args: FilterExpression[]);
-    evaluate(context: FilterContext): unknown;
-    toString(options?: SerializationOptions): string;
-    private unpack_node_list;
-}
-export declare function compare(left: unknown, operator: string, right: unknown): boolean;

package/dist/path/extra/expression.d.ts

@@ -1,6 +0,0 @@
-import { FilterExpression } from "../expression";
-import { FilterContext, Nothing } from "../types";
-export declare class CurrentKey extends FilterExpression {
-    evaluate(context: FilterContext): string | number | typeof Nothing;
-    toString(): string;
-}

package/dist/path/extra/selectors.d.ts

@@ -1,35 +0,0 @@
-import { JSONPathEnvironment } from "../environment";
-import { LogicalExpression } from "../expression";
-import { JSONPathNode } from "../node";
-import { JSONPathSelector } from "../selectors";
-import { Token } from "../token";
-import { type SerializationOptions } from "../types";
-export declare class KeySelector extends JSONPathSelector {
-    readonly environment: JSONPathEnvironment;
-    readonly token: Token;
-    readonly key: string;
-    constructor(environment: JSONPathEnvironment, token: Token, key: string);
-    resolve(node: JSONPathNode): JSONPathNode[];
-    lazyResolve(node: JSONPathNode): Generator<JSONPathNode>;
-    toString(options?: SerializationOptions): string;
-}
-/**
- * Object property name selector or array index selector.
- */
-export declare class KeysSelector extends JSONPathSelector {
-    readonly environment: JSONPathEnvironment;
-    readonly token: Token;
-    constructor(environment: JSONPathEnvironment, token: Token);
-    resolve(node: JSONPathNode): JSONPathNode[];
-    lazyResolve(node: JSONPathNode): Generator<JSONPathNode>;
-    toString(): string;
-}
-export declare class KeysFilterSelector extends JSONPathSelector {
-    readonly environment: JSONPathEnvironment;
-    readonly token: Token;
-    readonly expression: LogicalExpression;
-    constructor(environment: JSONPathEnvironment, token: Token, expression: LogicalExpression);
-    resolve(node: JSONPathNode): JSONPathNode[];
-    lazyResolve(node: JSONPathNode): Generator<JSONPathNode>;
-    toString(options?: SerializationOptions): string;
-}

package/dist/path/functions/count.d.ts

@@ -1,7 +0,0 @@
-import { JSONPathNodeList } from "../node";
-import { FilterFunction, FunctionExpressionType } from "./function";
-export declare class Count implements FilterFunction {
-    readonly argTypes: FunctionExpressionType[];
-    readonly returnType = FunctionExpressionType.ValueType;
-    call(nodes: JSONPathNodeList): number;
-}

package/dist/path/functions/function.d.ts

@@ -1,26 +0,0 @@
-/**
- * The type of a JSONPath filter function parameter or return value, as
- * described in See section 2.4.1 of RFC 9535.
- */
-export declare enum FunctionExpressionType {
-    ValueType = "ValueType",
-    LogicalType = "LogicalType",
-    NodesType = "NodesType"
-}
-/**
- * A JSONPath filter function definition.
- */
-export interface FilterFunction {
-    /**
-     * Argument types expected by the filter function.
-     */
-    argTypes: FunctionExpressionType[];
-    /**
-     * The type of the value returned by the filter function.
-     */
-    returnType: FunctionExpressionType;
-    /**
-     * A function with unknown number and type of arguments.
-     */
-    call(...args: unknown[]): unknown;
-}

package/dist/path/functions/has.d.ts

@@ -1,44 +0,0 @@
-import { FilterFunction, FunctionExpressionType } from "./function";
-export type HasFilterFunctionOptions = {
-    /**
-     * The maximum number of regular expressions to cache. Defaults
-     * to 10.
-     */
-    cacheSize?: number;
-    /**
-     * If _true_, throw errors from regex construction and matching.
-     * The standard and default behavior is to ignore these errors
-     * and return _false_.
-     */
-    throwErrors?: boolean;
-    /**
-     * If _true_, check that regexp patterns are valid according to I-Regexp.
-     * The standard and default behavior is to silently return _false_ if a
-     * pattern is invalid.
-     *
-     * If `iRegexpCheck` is _true_ and `throwErrors` is _true_, an `IRegexpError`
-     * will be thrown.
-     */
-    iRegexpCheck?: boolean;
-    /**
-     * if _true_, use regex search semantics when testing patterns against
-     * property names. Defaults to _true_.
-     */
-    search?: boolean;
-};
-/**
- * A function extension that returns `true` if the first argument is an object
- * value and it contains a property matching the second argument.
- */
-export declare class Has implements FilterFunction {
-    #private;
-    readonly options: HasFilterFunctionOptions;
-    readonly argTypes: FunctionExpressionType[];
-    readonly returnType = FunctionExpressionType.LogicalType;
-    readonly cacheSize: number;
-    readonly throwErrors: boolean;
-    readonly iRegexpCheck: boolean;
-    readonly search: boolean;
-    constructor(options?: HasFilterFunctionOptions);
-    call(value: unknown, pattern: string): boolean;
-}

package/dist/path/functions/index.d.ts

@@ -1,11 +0,0 @@
-export { Count } from "./count";
-export { Length } from "./length";
-export { Match } from "./match";
-export { Has } from "./has";
-export { Search } from "./search";
-export { Value } from "./value";
-export { FunctionExpressionType } from "./function";
-export type { FilterFunction } from "./function";
-export type { HasFilterFunctionOptions } from "./has";
-export type { MatchFilterFunctionOptions } from "./match";
-export type { SearchFilterFunctionOptions } from "./search";

package/dist/path/functions/length.d.ts

@@ -1,7 +0,0 @@
-import { FilterFunction, FunctionExpressionType } from "./function";
-import { Nothing } from "../types";
-export declare class Length implements FilterFunction {
-    readonly argTypes: FunctionExpressionType[];
-    readonly returnType = FunctionExpressionType.ValueType;
-    call(value: unknown): number | typeof Nothing;
-}