json-p3 2.3.0 → 2.3.1

package/dist/path/types.d.ts

@@ -0,0 +1,46 @@
+import { JSONValue } from "../types";
+import { JSONPathEnvironment } from "./environment";
+export declare const Nothing: unique symbol;
+/**
+ * ValueType for JSONPath function expression tye system.
+ */
+export type JSONPathValue = JSONValue | typeof Nothing;
+/**
+ * Object passed to `FilterExpression.evaluate()`.
+ */
+export type FilterContext = {
+    environment: JSONPathEnvironment;
+    currentValue: JSONValue;
+    rootValue: JSONValue;
+    lazy?: boolean;
+    currentKey?: string | number;
+};
+/**
+ * A type predicate for an object with a string property.
+ */
+export declare function hasStringKey(value: unknown, key: string): value is {
+    [key: string]: unknown;
+};
+export declare const KEY_MARK = "\u0002";
+/**
+ * Options for serializing paths.
+ */
+export type SerializationOptions = {
+    /**
+     * `pretty` paths always use:
+     *  - shorthand notation rather than dot notation where possible
+     *  - double quotes rather than single quotes for string literals and where shorthand
+     *    notation is not possible
+     *  - short escape sequences for common non-printing characters such as `\n` and `\t`
+     *
+     * `canonical` paths always use:
+     *  - bracket notation for name and wildcard selectors
+     *  - single quotes for name selectors and string literals
+     *  - short escape sequences for common non-printing characters such as `\n` and `\t`
+     *
+     * `canonical` paths will produce a normalized path where available, but cannot be
+     * considered normalized paths if the query does not represent a singular, absolute node.
+     */
+    form: "pretty" | "canonical";
+};
+export declare const defaultSerializationOptions: SerializationOptions;

package/dist/pointer/errors.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Base class for all JSON Pointer errors.
+ */
+export declare class JSONPointerError extends Error {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ * Base class for JSON Pointer resolution errors.
+ */
+export declare class JSONPointerResolutionError extends JSONPointerError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ * Error thrown due to an out of range index when resolving a JSON Pointer.
+ */
+export declare class JSONPointerIndexError extends JSONPointerResolutionError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ * Error thrown due to a missing property when resolving a JSON Pointer.
+ */
+export declare class JSONPointerKeyError extends JSONPointerResolutionError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ * Error thrown due to invalid JSON Pointer syntax.
+ */
+export declare class JSONPointerSyntaxError extends JSONPointerError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ * Error thrown when trying to resolve a property or index against a primitive value.
+ */
+export declare class JSONPointerTypeError extends JSONPointerResolutionError {
+    readonly message: string;
+    constructor(message: string);
+}

package/dist/pointer/index.d.ts

@@ -0,0 +1,24 @@
+import { JSONValue } from "../types";
+import { MaybeJSONValue } from "./pointer";
+export { JSONPointer, RelativeJSONPointer, UNDEFINED } from "./pointer";
+export type { MaybeJSONValue } from "./pointer";
+export { JSONPointerError, JSONPointerResolutionError, JSONPointerIndexError, JSONPointerKeyError, JSONPointerSyntaxError, JSONPointerTypeError, } from "./errors";
+/**
+ * Resolve JSON Pointer _pointer_ against JSON-like data _value_.
+ *
+ * @param pointer - A string representation of a JSON pointer.
+ * @param value - The target JSON-like value, possibly loaded using
+ *  `JSON.parse()`.
+ * @param fallback - A default value to return if _value_ has no
+ *   path matching `pointer`.
+ * @returns The value identified by _pointer_ or, if given, the fallback
+ *   value in the even of a `JSONPointerResolutionError`.
+ *
+ * @throws {@link JSONPointerResolutionError}
+ * If the value pointed to by _pointer_ does not exist in _value_, and
+ * no fallback value is given.
+ *
+ * @throws {@link JSONPointerSyntaxError}
+ * If _pointer_ is malformed according to RFC 6901.
+ */
+export declare function resolve(pointer: string, value: JSONValue, fallback?: MaybeJSONValue): JSONValue;

package/dist/pointer/pointer.d.ts

@@ -0,0 +1,106 @@
+import { JSONValue } from "../types";
+/**
+ * The symbol indicating the absence of a JSON value.
+ */
+export declare const UNDEFINED: unique symbol;
+export type MaybeJSONValue = JSONValue | typeof UNDEFINED;
+/**
+ * Identify a single value in JSON-like data, as per RFC 6901.
+ */
+export declare class JSONPointer {
+    #private;
+    tokens: string[];
+    /**
+     * @param pointer - A string representation of a JSON Pointer.
+     */
+    constructor(pointer: string);
+    static encode(tokens: string[]): string;
+    /**
+     * Resolve this pointer against JSON-like data _value_.
+     *
+     * @param value - The target JSON-like value, possibly loaded using
+     *  `JSON.parse()`.
+     * @param fallback - A default value to return if _value_ has no
+     *   path matching `pointer`.
+     * @returns The value identified by _pointer_ or, if given, the fallback
+     *   value in the even of a `JSONPointerResolutionError`.
+     *
+     * @throws {@link JSONPointerResolutionError}
+     * If the value pointed to by _pointer_ does not exist in _value_, and
+     * no fallback value is given.
+     */
+    resolve(value: JSONValue, fallback?: MaybeJSONValue): JSONValue;
+    /**
+     *
+     * @param value -
+     * @returns
+     */
+    resolveWithParent(value: JSONValue): [MaybeJSONValue, MaybeJSONValue];
+    /**
+     *
+     * @returns
+     */
+    toString(): string;
+    /**
+     * Return _true_ if this pointer points to a child of _pointer_.
+     */
+    isRelativeTo(pointer: JSONPointer): boolean;
+    protected parse(pointer: string): string[];
+    protected getItem(val: JSONValue, token: string, idx: number): JSONValue;
+    private _join;
+    /**
+     * Join this pointer with _tokens_.
+     *
+     * @param tokens - JSON Pointer strings, possibly without leading slashes.
+     * If a token or "part" does have a leading slash, the previous pointer is
+     * ignored and a new `JSONPointer` is created, then processing of the
+     * remaining tokens continues.
+     *
+     * @returns A new JSON Pointer that is the concatenation of all tokens or
+     * "parts".
+     */
+    join(...tokens: string[]): JSONPointer;
+    /**
+     * Return _true_ if this pointer can be resolved against _value_.
+     *
+     * Note that `JSONPointer.resolve()` can return legitimate falsy values
+     * that form part of the target JSON document. This method will return
+     * `true` if a falsy value is found.
+     */
+    exists(value: JSONValue): boolean;
+    /**
+     * Return this pointer's parent as a new `JSONPointer`.
+     *
+     * If this pointer points to the document root, _this_ is returned.
+     */
+    parent(): JSONPointer;
+    to(rel: string | RelativeJSONPointer): JSONPointer;
+}
+/**
+ * A relative JSON Pointer.
+ *
+ * See https://datatracker.ietf.org/doc/html/draft-hha-relative-json-pointer
+ */
+export declare class RelativeJSONPointer {
+    readonly origin: number;
+    readonly index: number;
+    readonly pointer: string | JSONPointer;
+    /**
+     *
+     * @param rel -
+     */
+    constructor(rel: string);
+    /**
+     *
+     * @returns
+     */
+    toString(): string;
+    /**
+     *
+     * @param pointer -
+     */
+    to(pointer: string | JSONPointer): JSONPointer;
+    protected parse(rel: string): [number, number, string | JSONPointer];
+    protected parseInt(s: string): number;
+    protected isIntLike(value: string | number | undefined): boolean;
+}

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Common types and type predicates.
+ */
+/**
+ * A JSON-like value.
+ */
+export type JSONValue = string | number | null | undefined | boolean | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+/**
+ * A type predicate for the Array object.
+ */
+export declare function isArray(value: unknown): value is unknown[];
+/**
+ * A type predicate for object.
+ */
+export declare function isObject(value: unknown): value is object;
+/**
+ * A type predicate for a string primitive.
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * A type predicate for a number primitive.
+ */
+export declare function isNumber(value: unknown): value is number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-p3",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "author": "James Prior",
   "license": "MIT",
   "description": "JSONPath, JSON Pointer and JSON Patch",
@@ -14,10 +14,10 @@
   },
   "scripts": {
     "test": "jest",
-    "build:types": "tsc --emitDeclarationOnly",
+    "build:types": "tsc -p tsconfig.build.json --emitDeclarationOnly",
     "build:js": "rollup -c",
     "build": "npm run build:types && npm run build:js",
-    "type-check": "tsc --noEmit",
+    "type-check": "tsc -p tsconfig.build.json --noEmit",
     "coverage": "jest --collectCoverage",
     "clean": "rm -rf ./lib ./dist ./coverage ./docs/docs/api",
     "lint": "eslint src tests --ext .js,.jsx,.ts,.tsx"