@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/objects/predicates.js

@@ -0,0 +1,68 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var predicates_exports = {};
+__export(predicates_exports, {
+  hasKeys: () => hasKeys,
+  hasOwn: () => hasOwn,
+  isObject: () => isObject,
+  isPlainObject: () => isPlainObject
+});
+module.exports = __toCommonJS(predicates_exports);
+var import_predicates = require("../arrays/predicates");
+var import_object = require("../primordials/object");
+// @__NO_SIDE_EFFECTS__
+function hasKeys(obj) {
+  if (obj === null || obj === void 0) {
+    return false;
+  }
+  for (const key in obj) {
+    if ((0, import_object.ObjectHasOwn)(obj, key)) {
+      return true;
+    }
+  }
+  return false;
+}
+// @__NO_SIDE_EFFECTS__
+function hasOwn(obj, propKey) {
+  if (obj === null || obj === void 0) {
+    return false;
+  }
+  return (0, import_object.ObjectHasOwn)(obj, propKey);
+}
+// @__NO_SIDE_EFFECTS__
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+// @__NO_SIDE_EFFECTS__
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || (0, import_predicates.isArray)(value)) {
+    return false;
+  }
+  const proto = (0, import_object.ObjectGetPrototypeOf)(value);
+  return proto === null || proto === import_object.ObjectPrototype;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hasKeys,
+  hasOwn,
+  isObject,
+  isPlainObject
+});

package/dist/objects/sort.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @file Sorted-object helpers: `entryKeyComparator`, `objectEntries`,
+ *   `toSortedObject`, `toSortedObjectFromEntries`. Symbol keys sort separately
+ *   from string keys (placed first in the resulting object) — this matters for
+ *   serialization stability since `Object.keys` and `JSON.stringify` will
+ *   iterate insertion order.
+ */
+import type { SortedObject } from './types';
+/**
+ * Compare two entry arrays by their keys for sorting.
+ *
+ * Used internally for alphabetically sorting object entries. String keys are
+ * compared directly, non-string keys are converted to strings first.
+ *
+ * @example
+ *   ;```ts
+ *   const entries = [
+ *     ['zebra', 1],
+ *     ['apple', 2],
+ *     ['banana', 3],
+ *   ]
+ *   entries.sort(entryKeyComparator)
+ *   // [['apple', 2], ['banana', 3], ['zebra', 1]]
+ *   ```
+ *
+ * @param a - First entry tuple [key, value]
+ * @param b - Second entry tuple [key, value]
+ *
+ * @returns Negative if a < b, positive if a > b, zero if equal
+ */
+export declare function entryKeyComparator(a: [PropertyKey, unknown], b: [PropertyKey, unknown]): number;
+/**
+ * Get all own property entries (key-value pairs) from an object.
+ *
+ * Unlike `Object.entries()`, this includes non-enumerable properties and symbol
+ * keys. Returns an empty array for null/undefined.
+ *
+ * @example
+ *   ;```ts
+ *   objectEntries({ a: 1, b: 2 }) // [['a', 1], ['b', 2]]
+ *   objectEntries({ [Symbol('k')]: 'v', x: 10 }) // [[Symbol(k), 'v'], ['x', 10]]
+ *   objectEntries(null) // []
+ *   ```
+ *
+ * @param obj - The object to get entries from.
+ *
+ * @returns Array of [key, value] tuples, or empty array for null/undefined
+ */
+export declare function objectEntries(obj: unknown): Array<[PropertyKey, unknown]>;
+/**
+ * Convert an object to a new object with sorted keys.
+ *
+ * Creates a new object with the same properties as the input, but with keys
+ * sorted alphabetically. Symbol keys are sorted separately and placed first.
+ * This is useful for consistent key ordering in serialization or comparisons.
+ *
+ * @example
+ *   ;```ts
+ *   toSortedObject({ z: 1, a: 2, m: 3 }) // { a: 2, m: 3, z: 1 }
+ *   ```
+ *
+ * @param obj - The object to sort.
+ *
+ * @returns A new object with sorted keys
+ */
+export declare function toSortedObject<T extends object>(obj: T): T;
+/**
+ * Create an object from entries with sorted keys.
+ *
+ * Takes an iterable of [key, value] entries and creates a new object with keys
+ * sorted alphabetically. Symbol keys are sorted separately and placed first in
+ * the resulting object.
+ *
+ * @example
+ *   ;```ts
+ *   toSortedObjectFromEntries([
+ *     ['z', 1],
+ *     ['a', 2],
+ *     ['m', 3],
+ *   ])
+ *   // { a: 2, m: 3, z: 1 }
+ *   ```
+ *
+ * @param entries - Iterable of [key, value] tuples.
+ *
+ * @returns A new object with sorted keys
+ */
+export declare function toSortedObjectFromEntries<T = unknown>(entries: Iterable<[PropertyKey, T]>): SortedObject<T>;

package/dist/objects/sort.js

@@ -0,0 +1,85 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sort_exports = {};
+__export(sort_exports, {
+  entryKeyComparator: () => entryKeyComparator,
+  objectEntries: () => objectEntries,
+  toSortedObject: () => toSortedObject,
+  toSortedObjectFromEntries: () => toSortedObjectFromEntries
+});
+module.exports = __toCommonJS(sort_exports);
+var import_object = require("../primordials/object");
+var import_reflect = require("../primordials/reflect");
+var import_natural = require("../sorts/natural");
+// @__NO_SIDE_EFFECTS__
+function entryKeyComparator(a, b) {
+  const keyA = a[0];
+  const keyB = b[0];
+  const strKeyA = typeof keyA === "string" ? keyA : String(keyA);
+  const strKeyB = typeof keyB === "string" ? keyB : String(keyB);
+  return (0, import_natural.localeCompare)(strKeyA, strKeyB);
+}
+// @__NO_SIDE_EFFECTS__
+function objectEntries(obj) {
+  if (obj === null || obj === void 0) {
+    return [];
+  }
+  const keys = (0, import_reflect.ReflectOwnKeys)(obj);
+  const { length } = keys;
+  const entries = Array(length);
+  const record = obj;
+  for (let i = 0; i < length; i += 1) {
+    const key = keys[i];
+    entries[i] = [key, record[key]];
+  }
+  return entries;
+}
+// @__NO_SIDE_EFFECTS__
+function toSortedObject(obj) {
+  return /* @__PURE__ */ toSortedObjectFromEntries(/* @__PURE__ */ objectEntries(obj));
+}
+// @__NO_SIDE_EFFECTS__
+function toSortedObjectFromEntries(entries) {
+  const otherEntries = [];
+  const symbolEntries = [];
+  for (const entry of entries) {
+    if (typeof entry[0] === "symbol") {
+      symbolEntries.push(entry);
+    } else {
+      otherEntries.push(entry);
+    }
+  }
+  if (!otherEntries.length && !symbolEntries.length) {
+    return {};
+  }
+  return (0, import_object.ObjectFromEntries)([
+    // The String constructor is safe to use with symbols.
+    ...symbolEntries.sort(entryKeyComparator),
+    ...otherEntries.sort(entryKeyComparator)
+  ]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  entryKeyComparator,
+  objectEntries,
+  toSortedObject,
+  toSortedObjectFromEntries
+});

package/dist/objects/types.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @file Public type surface for `objects/*` modules — getter definition shapes
+ *   and the `Remap` type helper. Pure types, no runtime side effects.
+ */
+/**
+ * Record of property keys mapped to getter functions. Used for defining lazy
+ * getters on objects.
+ */
+export type GetterDefObj = {
+    [key: PropertyKey]: () => unknown;
+};
+/**
+ * Statistics tracking for lazy getter initialization. Keeps track of which lazy
+ * getters have been accessed and initialized.
+ */
+export type LazyGetterStats = {
+    initialized?: Set<PropertyKey> | undefined;
+};
+/**
+ * Configuration options for creating constants objects.
+ */
+export type ConstantsObjectOptions = {
+    /**
+     * Lazy getter definitions to attach to the object.
+     *
+     * @default undefined
+     */
+    getters?: GetterDefObj | undefined;
+    /**
+     * Internal properties to store under `kInternalsSymbol`.
+     *
+     * @default undefined
+     */
+    internals?: object | undefined;
+    /**
+     * Properties to mix into the object (lower priority than `props`).
+     *
+     * @default undefined
+     */
+    mixin?: object | undefined;
+};
+/**
+ * Type helper that creates a remapped type with fresh property mapping. Useful
+ * for flattening intersection types into a single object type.
+ */
+export type Remap<T> = {
+    [K in keyof T]: T[K];
+} extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+/**
+ * Type for dynamic lazy getter record.
+ */
+export type LazyGetterRecord<T> = {
+    [key: PropertyKey]: () => T;
+};
+/**
+ * Type for generic property bag.
+ */
+export type PropertyBag = {
+    [key: PropertyKey]: unknown;
+};
+/**
+ * Type for generic sorted object entries.
+ */
+export type SortedObject<T> = {
+    [key: PropertyKey]: T;
+};

package/dist/objects/types.js

@@ -0,0 +1,18 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/packages/edit-class.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @file The `EditablePackageJson` class factory. Split out of
+ *   `packages/edit.ts` for size hygiene. Wraps `@npmcli/package-json` with
+ *   Socket-specific knobs: path tracking, a `_canSave` guard for content-only
+ *   instances, async + sync save paths that honor `EditablePackageJsonOptions`
+ *   formatting.
+ *
+ *   - `getEditablePackageJsonClass` — lazy class accessor (Webpack-safe)
+ */
+import type { EditablePackageJsonOptions, NormalizeOptions } from './types';
+import type { EditablePackageJsonInstance } from './edit';
+/**
+ * Private constructor interface for the lazily-built `EditablePackageJson`
+ * class. Not exported because consumers go through
+ * `getEditablePackageJsonClass()`.
+ */
+interface EditablePackageJsonConstructor {
+    new (): EditablePackageJsonInstance;
+    fixSteps: unknown[];
+    normalizeSteps: unknown[];
+    prepareSteps: unknown[];
+    create(path: string, opts?: EditablePackageJsonOptions): Promise<EditablePackageJsonInstance>;
+    fix(path: string, opts?: unknown): Promise<EditablePackageJsonInstance>;
+    load(path: string, opts?: EditablePackageJsonOptions): Promise<EditablePackageJsonInstance>;
+    normalize(path: string, opts?: NormalizeOptions): Promise<EditablePackageJsonInstance>;
+    prepare(path: string, opts?: unknown): Promise<EditablePackageJsonInstance>;
+}
+/**
+ * Get the EditablePackageJson class for package.json manipulation.
+ *
+ * @example
+ *   ;```typescript
+ *   const EditablePackageJson = getEditablePackageJsonClass()
+ *   const pkg = await EditablePackageJson.load('/tmp/my-project')
+ *   console.log(pkg.content.name)
+ *   ```
+ */
+export declare function getEditablePackageJsonClass(): EditablePackageJsonConstructor;
+export {};

package/dist/packages/edit-class.js

@@ -0,0 +1,269 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var edit_class_exports = {};
+__export(edit_class_exports, {
+  getEditablePackageJsonClass: () => getEditablePackageJsonClass
+});
+module.exports = __toCommonJS(edit_class_exports);
+var import_package_json = __toESM(require("../external/@npmcli/package-json"));
+var import_read_package = require("../external/@npmcli/package-json/lib/read-package");
+var import_sort = require("../external/@npmcli/package-json/lib/sort");
+var import_format = require("../json/format");
+var import_error = require("../primordials/error");
+var import_json = require("../primordials/json");
+var import_string = require("../primordials/string");
+var import_fs = require("../node/fs");
+var import_path = require("../node/path");
+var import_util = require("../node/util");
+let _EditablePackageJsonClass;
+// @__NO_SIDE_EFFECTS__
+function getEditablePackageJsonClass() {
+  if (_EditablePackageJsonClass === void 0) {
+    _EditablePackageJsonClass = class EditablePackageJson extends import_package_json.default {
+      static fixSteps = import_package_json.default.fixSteps;
+      static normalizeSteps = import_package_json.default.normalizeSteps;
+      static prepareSteps = import_package_json.default.prepareSteps;
+      _canSave = true;
+      _path = void 0;
+      _readFileContent = "";
+      _readFileJson = void 0;
+      get content() {
+        return super.content;
+      }
+      get filename() {
+        const path = this._path;
+        if (!path) {
+          return "";
+        }
+        if ((0, import_string.StringPrototypeEndsWith)(path, "package.json")) {
+          return path;
+        }
+        const nodePath = (0, import_path.getNodePath)();
+        return nodePath.join(path, "package.json");
+      }
+      static async create(path, opts = {}) {
+        const p = new _EditablePackageJsonClass();
+        await p.create(path);
+        return opts.data ? p.update(opts.data) : p;
+      }
+      static async fix(path, opts) {
+        const p = new _EditablePackageJsonClass();
+        await p.load(path, true);
+        return await p.fix(opts);
+      }
+      static async load(path, opts = {}) {
+        const p = new _EditablePackageJsonClass();
+        if (!opts.create) {
+          return await p.load(path);
+        }
+        try {
+          return await p.load(path);
+        } catch (err) {
+          if (!err.message.startsWith("Could not read package.json")) {
+            throw err;
+          }
+          return p.create(path);
+        }
+      }
+      static async normalize(path, opts) {
+        const p = new _EditablePackageJsonClass();
+        await p.load(path);
+        return await p.normalize(opts);
+      }
+      static async prepare(path, opts) {
+        const p = new _EditablePackageJsonClass();
+        await p.load(path, true);
+        return await p.prepare(opts);
+      }
+      create(path) {
+        super.create(path);
+        this._path = path;
+        return this;
+      }
+      async fix(opts = {}) {
+        await super.fix(opts);
+        return this;
+      }
+      fromContent(data) {
+        super.fromContent(data);
+        this._canSave = false;
+        return this;
+      }
+      fromJSON(data) {
+        super.fromJSON(data);
+        return this;
+      }
+      async load(path, create) {
+        this._path = path;
+        const { promises: fsPromises } = (0, import_fs.getNodeFs)();
+        let parseErr;
+        try {
+          this._readFileContent = await (0, import_read_package.read)(this.filename);
+        } catch (e) {
+          if (!create) {
+            throw e;
+          }
+          parseErr = e;
+        }
+        if (parseErr) {
+          const nodePath = (0, import_path.getNodePath)();
+          const indexFile = nodePath.resolve(this.path || "", "index.js");
+          let indexFileContent;
+          try {
+            indexFileContent = await fsPromises.readFile(indexFile, "utf8");
+          } catch {
+            throw parseErr;
+          }
+          try {
+            this.fromContent(indexFileContent);
+          } catch {
+            throw parseErr;
+          }
+          this._canSave = false;
+          return this;
+        }
+        this.fromJSON(this._readFileContent);
+        this._readFileJson = (0, import_read_package.parse)(this._readFileContent);
+        return this;
+      }
+      async normalize(opts = {}) {
+        await super.normalize(opts);
+        return this;
+      }
+      get path() {
+        return this._path;
+      }
+      async prepare(opts = {}) {
+        await super.prepare(opts);
+        return this;
+      }
+      async save(options) {
+        if (!this._canSave || this.content === void 0) {
+          throw new import_error.ErrorCtor("No package.json to save to");
+        }
+        if (!(0, import_format.shouldSave)(
+          this.content,
+          this._readFileJson,
+          this._readFileContent,
+          { ...options, sortFn: options?.sort ? import_sort.packageSort : void 0 }
+        )) {
+          return false;
+        }
+        const content = (0, import_format.stripFormattingSymbols)(
+          this.content
+        );
+        const sortedContent = options?.sort ? (0, import_sort.packageSort)(content) : content;
+        const formatting = (0, import_format.getFormattingFromContent)(
+          this.content
+        );
+        const fileContent = (0, import_format.stringifyWithFormatting)(sortedContent, formatting);
+        const { promises: fsPromises } = (0, import_fs.getNodeFs)();
+        await fsPromises.writeFile(this.filename, fileContent);
+        this._readFileContent = fileContent;
+        this._readFileJson = (0, import_read_package.parse)(fileContent);
+        return true;
+      }
+      saveSync(options) {
+        if (!this._canSave || this.content === void 0) {
+          throw new import_error.ErrorCtor("No package.json to save to");
+        }
+        const { ignoreWhitespace = false, sort = false } = {
+          __proto__: null,
+          ...options
+        };
+        const {
+          [Symbol.for("indent")]: indent,
+          [Symbol.for("newline")]: newline,
+          ...rest
+        } = this.content;
+        const content = sort ? (0, import_sort.packageSort)(rest) : rest;
+        if (ignoreWhitespace && (0, import_util.getNodeUtil)().isDeepStrictEqual(content, this._readFileJson)) {
+          return false;
+        }
+        const format = indent === void 0 || indent === null ? "  " : indent;
+        const eol = newline === void 0 || newline === null ? "\n" : newline;
+        const fileContent = `${(0, import_json.JSONStringify)(
+          content,
+          void 0,
+          format
+        )}
+`.replace(/\n/g, eol);
+        if (!ignoreWhitespace && fileContent.trim() === this._readFileContent.trim()) {
+          return false;
+        }
+        const fs = (0, import_fs.getNodeFs)();
+        fs.writeFileSync(this.filename, fileContent);
+        this._readFileContent = fileContent;
+        this._readFileJson = (0, import_read_package.parse)(fileContent);
+        return true;
+      }
+      update(content) {
+        super.update(content);
+        return this;
+      }
+      willSave(options) {
+        const { ignoreWhitespace = false, sort = false } = {
+          __proto__: null,
+          ...options
+        };
+        if (!this._canSave || this.content === void 0) {
+          return false;
+        }
+        const {
+          [Symbol.for("indent")]: indent,
+          [Symbol.for("newline")]: newline,
+          ...rest
+        } = this.content;
+        const content = sort ? (0, import_sort.packageSort)(rest) : rest;
+        if (ignoreWhitespace && (0, import_util.getNodeUtil)().isDeepStrictEqual(content, this._readFileJson)) {
+          return false;
+        }
+        const format = indent === void 0 || indent === null ? "  " : indent;
+        const eol = newline === void 0 || newline === null ? "\n" : newline;
+        const fileContent = `${(0, import_json.JSONStringify)(
+          content,
+          void 0,
+          format
+        )}
+`.replace(/\n/g, eol);
+        if (!ignoreWhitespace && fileContent.trim() === this._readFileContent.trim()) {
+          return false;
+        }
+        return true;
+      }
+    };
+  }
+  return _EditablePackageJsonClass;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEditablePackageJsonClass
+});