@vltpkg/dot-prop 1.0.0-rc.23 → 1.0.0-rc.25

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export type ArrayArg = unknown[];
+export type ObjectArg = Record<PropertyKey, unknown>;
+export type Arg = ArrayArg | ObjectArg;
+export declare const Characters: {
+    readonly Escape: "\\";
+    readonly Dot: ".";
+    readonly Empty: "";
+    readonly LeftBracket: "[";
+    readonly RightBracket: "]";
+};
+export type Character = (typeof Characters)[keyof typeof Characters] | (string & {});
+export declare const Parts: {
+    readonly Start: "start";
+    readonly Index: "index";
+    readonly IndexEnd: "indexEnd";
+    readonly Property: "property";
+};
+export type Part = (typeof Parts)[keyof typeof Parts];
+export declare const get: (ogObject: Arg, path: string, defaultValue?: unknown) => unknown;
+export declare const set: <T extends Arg>(object: T, path: string, value: unknown) => T;
+export declare const del: (object: Arg, path: string) => boolean;
+export declare const has: (object: Arg, path: string) => boolean;

package/dist/index.js

@@ -0,0 +1,234 @@
+const DISALLOWED_KEYS = new Set([
+    '__proto__',
+    'prototype',
+    'constructor',
+]);
+const DIGITS = new Set('0123456789');
+const ARRAY_PUSH = Symbol('ARRAY_PUSH');
+export const Characters = {
+    Escape: '\\',
+    Dot: '.',
+    Empty: '',
+    LeftBracket: '[',
+    RightBracket: ']',
+};
+export const Parts = {
+    Start: 'start',
+    Index: 'index',
+    IndexEnd: 'indexEnd',
+    Property: 'property',
+};
+const checkInvalidCharacter = (part, current, msg) => {
+    if (current === part) {
+        if (msg === undefined) {
+            switch (current) {
+                case Parts.Index:
+                    msg = 'character in an index';
+                    break;
+                case Parts.IndexEnd:
+                    msg = 'character after an index';
+                    break;
+                /* c8 ignore next 3 */
+                default:
+                    msg = '';
+                    break;
+            }
+        }
+        throw new Error(`Invalid ${msg}`.trim());
+    }
+};
+const getPathSegments = (path, allowEmptyIndex = false) => {
+    const segments = [];
+    let currentSegment = Characters.Empty;
+    let currentPart = Parts.Start;
+    let isIgnoring = false;
+    for (const character of path.split('')) {
+        switch (character) {
+            case Characters.Escape: {
+                checkInvalidCharacter(Parts.Index, currentPart);
+                checkInvalidCharacter(Parts.IndexEnd, currentPart);
+                if (isIgnoring)
+                    currentSegment += character;
+                currentPart = Parts.Property;
+                isIgnoring = !isIgnoring;
+                break;
+            }
+            case Characters.Dot: {
+                checkInvalidCharacter(Parts.Index, currentPart);
+                if (currentPart === Parts.IndexEnd) {
+                    currentPart = Parts.Property;
+                    break;
+                }
+                if (isIgnoring) {
+                    isIgnoring = false;
+                    currentSegment += character;
+                    break;
+                }
+                if (DISALLOWED_KEYS.has(currentSegment))
+                    return [];
+                segments.push(currentSegment);
+                currentSegment = Characters.Empty;
+                currentPart = Parts.Property;
+                break;
+            }
+            case Characters.LeftBracket: {
+                checkInvalidCharacter(Parts.Index, currentPart);
+                if (currentPart === Parts.IndexEnd) {
+                    currentPart = Parts.Index;
+                    break;
+                }
+                if (isIgnoring) {
+                    isIgnoring = false;
+                    currentSegment += character;
+                    break;
+                }
+                if (currentPart === Parts.Property) {
+                    if (DISALLOWED_KEYS.has(currentSegment))
+                        return [];
+                    segments.push(currentSegment);
+                    currentSegment = Characters.Empty;
+                }
+                currentPart = Parts.Index;
+                break;
+            }
+            case Characters.RightBracket: {
+                if (currentPart === Parts.Index) {
+                    if (allowEmptyIndex)
+                        checkInvalidCharacter(Characters.Empty, currentSegment, 'empty index');
+                    segments.push(currentSegment === Characters.Empty ?
+                        ARRAY_PUSH
+                        : Number.parseInt(currentSegment, 10));
+                    currentPart = Parts.IndexEnd;
+                    currentSegment = Characters.Empty;
+                    break;
+                }
+                // Falls through
+            }
+            default: {
+                if (!DIGITS.has(character))
+                    checkInvalidCharacter(Parts.Index, currentPart);
+                checkInvalidCharacter(Parts.IndexEnd, currentPart);
+                if (currentPart === Parts.Start)
+                    currentPart = Parts.Property;
+                if (isIgnoring) {
+                    isIgnoring = false;
+                    currentSegment += Characters.Escape;
+                }
+                currentSegment += character;
+            }
+        }
+    }
+    if (isIgnoring)
+        currentSegment += Characters.Escape;
+    checkInvalidCharacter(Parts.Index, currentPart, 'index was not closed');
+    if (currentPart === Parts.Property) {
+        if (DISALLOWED_KEYS.has(currentSegment))
+            return [];
+        segments.push(currentSegment);
+    }
+    else if (currentPart === Parts.Start) {
+        segments.push(Characters.Empty);
+    }
+    return segments;
+};
+const isObject = (value) => value !== null && typeof value === 'object';
+const isLast = (arr, i) => i === arr.length - 1;
+const isStringIndex = (object, key) => {
+    if (typeof key !== 'symbol' &&
+        typeof key !== 'number' &&
+        Array.isArray(object)) {
+        const index = Number.parseInt(key, 10);
+        return (Number.isInteger(index) &&
+            object[index] === object[key]);
+    }
+    return false;
+};
+const assertNotStringIndex = (object, key) => {
+    if (isStringIndex(object, key)) {
+        throw new Error('Cannot use string index');
+    }
+};
+export const get = (ogObject, path, defaultValue) => {
+    let object = ogObject;
+    const pathArray = getPathSegments(path, true);
+    if (!pathArray.length) {
+        return defaultValue;
+    }
+    for (const [index, key] of pathArray.entries()) {
+        if (isStringIndex(object, key)) {
+            object = isLast(pathArray, index) ? undefined : null;
+        }
+        else {
+            object = object[key];
+        }
+        if ((object === undefined || object === null) &&
+            !isLast(pathArray, index)) {
+            // `object` is either `undefined` or `null` so we want to stop the loop,
+            // and if this is not the last bit of the path, and if it didn't return
+            // `undefined` it would return `null` if `object` is `null` but we want
+            // `get({foo: null}, 'foo.bar')` to equal `undefined`, or the supplied
+            // value, not `null`
+            return defaultValue;
+        }
+    }
+    return object === undefined ? defaultValue : object;
+};
+export const set = (object, path, value) => {
+    const root = object;
+    const pathArray = getPathSegments(path);
+    for (const [index, key] of pathArray.entries()) {
+        assertNotStringIndex(object, key);
+        if (isLast(pathArray, index)) {
+            if (key === ARRAY_PUSH) {
+                ;
+                object.push(value);
+            }
+            else {
+                ;
+                object[key] = value;
+            }
+        }
+        else if (!isObject(object[key])) {
+            const next = pathArray[index + 1];
+            object[key] =
+                typeof next === 'number' || next === ARRAY_PUSH ? [] : {};
+        }
+        object = object[key];
+    }
+    return root;
+};
+export const del = (object, path) => {
+    const pathArray = getPathSegments(path);
+    for (const [index, key] of pathArray.entries()) {
+        assertNotStringIndex(object, key);
+        if (isLast(pathArray, index)) {
+            if (Array.isArray(object)) {
+                object.splice(key, 1);
+            }
+            else {
+                delete object[key];
+            }
+            return true;
+        }
+        object = object[key];
+        if (!isObject(object)) {
+            return false;
+        }
+    }
+    return false;
+};
+export const has = (object, path) => {
+    const pathArray = getPathSegments(path);
+    if (!pathArray.length) {
+        return false;
+    }
+    for (const key of pathArray) {
+        if (!isObject(object) ||
+            !(key in object) ||
+            isStringIndex(object, key)) {
+            return false;
+        }
+        object = object[key];
+    }
+    return true;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vltpkg/dot-prop",
   "description": "Get and manipulate an object using strings",
-  "version": "1.0.0-rc.23",
+  "version": "1.0.0-rc.25",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vltpkg/vltpkg.git",