@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/packages/edit.d.ts

@@ -1,130 +1,129 @@
 /**
- * @fileoverview Editable package.json manipulation utilities.
+ * @file Editable package.json manipulation utilities. Convenience wrappers
+ *   around the `EditablePackageJson` class. Both the in-memory and path-backed
+ *   flows funnel through the same two entry points — pass `path` to persist,
+ *   omit it to stay in memory:
+ *
+ *   - `EditablePackageJsonInstance` — public interface for instances
+ *   - `toEditablePackageJson` — async (in-memory if no `path`, loads from disk if
+ *     `path` set)
+ *   - `toEditablePackageJsonSync` — sync version of the above The class factory
+ *     lives in a sibling leaf and is re-exported here so existing
+ *     `packages/edit` importers keep working unchanged:
+ *   - `getEditablePackageJsonClass` — `./edit-class` Lazy `node:fs` / `node:path`
+ *     / `node:util` loaders use the canonical `getNodeFs` / `getNodePath` /
+ *     `getNodeUtil` helpers from `@socketsecurity/lib/node/{fs,path,util}`.
  */
-import type { EditablePackageJsonOptions, NormalizeOptions, PackageJson, SaveOptions } from '../packages';
-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>;
-}
+import type { EditablePackageJsonOptions, NormalizeOptions, PackageJson, SaveOptions } from './types';
 /**
- * EditablePackageJson instance interface extending NPMCliPackageJson functionality.
- * Provides enhanced package.json manipulation with Socket-specific features.
+ * EditablePackageJson instance interface extending NPMCliPackageJson
+ * functionality. Provides enhanced package.json manipulation with
+ * Socket-specific features.
+ *
  * @extends NPMCliPackageJson (from @npmcli/package-json)
  */
 export interface EditablePackageJsonInstance {
     /**
      * The parsed package.json content as a readonly object.
+     *
      * @readonly
      */
     content: Readonly<PackageJson>;
     /**
      * Create a new package.json file at the specified path.
-     * @param path - The directory path where package.json will be created
+     *
+     * @param path - The directory path where package.json will be created.
      */
     create(path: string): this;
     /**
      * Apply automatic fixes to the package.json based on npm standards.
-     * @param opts - Optional fix configuration
+     *
+     * @param opts - Optional fix configuration.
      */
     fix(opts?: unknown | undefined): Promise<this>;
     /**
      * Initialize the instance from a content object.
-     * @param content - The package.json content object
+     *
+     * @param content - The package.json content object.
      */
     fromContent(content: unknown): this;
     /**
      * Initialize the instance from a JSON string.
-     * @param json - The package.json content as a JSON string
+     *
+     * @param json - The package.json content as a JSON string.
      */
     fromJSON(json: string): this;
     /**
      * Load a package.json file from the specified path.
-     * @param path - The directory containing the package.json
-     * @param create - Whether to create the file if it doesn't exist
+     *
+     * @param path - The directory containing the package.json.
+     * @param create - Whether to create the file if it doesn't exist.
      */
     load(path: string, create?: boolean): Promise<this>;
     /**
      * Normalize the package.json content according to npm standards.
-     * @param opts - Normalization options
+     *
+     * @param opts - Normalization options.
      */
     normalize(opts?: NormalizeOptions): Promise<this>;
     /**
      * Prepare the package.json for publishing.
-     * @param opts - Preparation options
+     *
+     * @param opts - Preparation options.
      */
     prepare(opts?: unknown): Promise<this>;
     /**
      * Update the package.json content with new values.
-     * @param content - Partial package.json object with fields to update
+     *
+     * @param content - Partial package.json object with fields to update.
+     *
      * @override from NPMCliPackageJson
      */
     update(content: Partial<PackageJson>): this;
     /**
      * Save the package.json file to disk.
-     * @param options - Save options for formatting and sorting
+     *
+     * @param options - Save options for formatting and sorting.
+     *
      * @override from NPMCliPackageJson
      */
     save(options?: SaveOptions | undefined): Promise<boolean>;
     /**
      * Synchronously save the package.json file to disk.
-     * @param options - Save options for formatting and sorting
+     *
+     * @param options - Save options for formatting and sorting.
      */
     saveSync(options?: SaveOptions | undefined): boolean;
     /**
      * Check if the package.json will be saved based on current changes.
-     * @param options - Save options to evaluate
+     *
+     * @param options - Save options to evaluate.
      */
     willSave(options?: SaveOptions | undefined): boolean;
 }
-/**
- * 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;
-/**
- * Convert a package.json object to an editable instance.
- *
- * @example
- * ```typescript
- * const editable = pkgJsonToEditable({ name: 'my-pkg', version: '1.0.0' })
- * ```
- */
-export declare function pkgJsonToEditable(pkgJson: PackageJson, options?: EditablePackageJsonOptions): unknown;
 /**
  * Convert package.json to editable instance with file persistence.
  *
  * @example
- * ```typescript
- * const editable = await toEditablePackageJson(
- *   { name: 'my-pkg', version: '1.0.0' },
- *   { path: '/tmp/my-project' }
- * )
- * ```
+ *   ;```typescript
+ *   const editable = await toEditablePackageJson(
+ *     { name: 'my-pkg', version: '1.0.0' },
+ *     { path: '/tmp/my-project' },
+ *   )
+ *   ```
  */
 export declare function toEditablePackageJson(pkgJson: PackageJson, options?: EditablePackageJsonOptions): Promise<unknown>;
 /**
- * Convert package.json to editable instance with file persistence synchronously.
+ * Convert package.json to editable instance with file persistence
+ * synchronously.
  *
  * @example
- * ```typescript
- * const editable = toEditablePackageJsonSync(
- *   { name: 'my-pkg', version: '1.0.0' },
- *   { path: '/tmp/my-project' }
- * )
- * ```
+ *   ;```typescript
+ *   const editable = toEditablePackageJsonSync(
+ *     { name: 'my-pkg', version: '1.0.0' },
+ *     { path: '/tmp/my-project' },
+ *   )
+ *   ```
  */
 export declare function toEditablePackageJsonSync(pkgJson: PackageJson, options?: EditablePackageJsonOptions): unknown;
-export {};
+export { getEditablePackageJsonClass } from './edit-class';

package/dist/packages/edit.js

@@ -1,11 +1,9 @@
 "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)
@@ -19,305 +17,41 @@ var __copyProps = (to, from, except, desc) => {
   }
   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_exports = {};
 __export(edit_exports, {
-  getEditablePackageJsonClass: () => getEditablePackageJsonClass,
-  pkgJsonToEditable: () => pkgJsonToEditable,
+  getEditablePackageJsonClass: () => import_edit_class2.getEditablePackageJsonClass,
   toEditablePackageJson: () => toEditablePackageJson,
   toEditablePackageJsonSync: () => toEditablePackageJsonSync
 });
 module.exports = __toCommonJS(edit_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_json = require("../primordials/json");
 var import_normalize = require("../paths/normalize");
-var import_normalize2 = require("./normalize");
 var import_packages = require("../paths/packages");
-var import_primordials = require("../primordials");
-let _EditablePackageJsonClass;
-let _fs;
-// @__NO_SIDE_EFFECTS__
-function getFs() {
-  if (_fs === void 0) {
-    _fs = require("node:fs");
-  }
-  return _fs;
-}
-let _path;
-// @__NO_SIDE_EFFECTS__
-function getPath() {
-  if (_path === void 0) {
-    _path = require("node:path");
-  }
-  return _path;
-}
-let _util;
-// @__NO_SIDE_EFFECTS__
-function getUtil() {
-  if (_util === void 0) {
-    _util = require("node:util");
-  }
-  return _util;
-}
-// @__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_primordials.StringPrototypeEndsWith)(path, "package.json")) {
-          return path;
-        }
-        const nodePath = /* @__PURE__ */ getPath();
-        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 } = /* @__PURE__ */ getFs();
-        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 = /* @__PURE__ */ getPath();
-          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_primordials.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 } = /* @__PURE__ */ getFs();
-        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_primordials.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 && (/* @__PURE__ */ getUtil()).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_primordials.JSONStringify)(
-          content,
-          void 0,
-          format
-        )}
-`.replace(/\n/g, eol);
-        if (!ignoreWhitespace && fileContent.trim() === this._readFileContent.trim()) {
-          return false;
-        }
-        const fs = /* @__PURE__ */ getFs();
-        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 && (/* @__PURE__ */ getUtil()).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_primordials.JSONStringify)(
-          content,
-          void 0,
-          format
-        )}
-`.replace(/\n/g, eol);
-        if (!ignoreWhitespace && fileContent.trim() === this._readFileContent.trim()) {
-          return false;
-        }
-        return true;
-      }
-    };
-  }
-  return _EditablePackageJsonClass;
-}
-// @__NO_SIDE_EFFECTS__
-function pkgJsonToEditable(pkgJson, options) {
-  const { normalize, ...normalizeOptions } = {
-    __proto__: null,
-    ...options
-  };
-  const EditablePackageJson = /* @__PURE__ */ getEditablePackageJsonClass();
-  return new EditablePackageJson().fromContent(
-    normalize ? (0, import_normalize2.normalizePackageJson)(pkgJson, normalizeOptions) : pkgJson
-  );
-}
+var import_edit_class = require("./edit-class");
+var import_normalize2 = require("./normalize");
+var import_edit_class2 = require("./edit-class");
 // @__NO_SIDE_EFFECTS__
 async function toEditablePackageJson(pkgJson, options) {
-  const { path: filepath, ...pkgJsonToEditableOptions } = {
+  const { path: filepath, ...restOptions } = {
     __proto__: null,
     ...options
   };
-  const { normalize, ...normalizeOptions } = pkgJsonToEditableOptions;
+  const { normalize, ...normalizeOptions } = restOptions;
+  const EditablePackageJson = (0, import_edit_class.getEditablePackageJsonClass)();
   if (typeof filepath !== "string") {
-    return /* @__PURE__ */ pkgJsonToEditable(pkgJson, pkgJsonToEditableOptions);
+    return new EditablePackageJson().fromContent(
+      normalize ? (0, import_normalize2.normalizePackageJson)(pkgJson, normalizeOptions) : pkgJson
+    );
   }
-  const EditablePackageJson = /* @__PURE__ */ getEditablePackageJsonClass();
   const pkgJsonPath = (0, import_packages.resolvePackageJsonDirname)(filepath);
   return (await EditablePackageJson.load(pkgJsonPath, { create: true })).fromJSON(
-    `${(0, import_primordials.JSONStringify)(
+    `${(0, import_json.JSONStringify)(
       normalize ? (0, import_normalize2.normalizePackageJson)(pkgJson, {
         ...(0, import_normalize.isNodeModules)(pkgJsonPath) ? {} : { preserve: ["repository"] },
         ...normalizeOptions
       }) : pkgJson,
-      null,
+      void 0,
       2
     )}
 `
@@ -325,23 +59,25 @@ async function toEditablePackageJson(pkgJson, options) {
 }
 // @__NO_SIDE_EFFECTS__
 function toEditablePackageJsonSync(pkgJson, options) {
-  const { path: filepath, ...pkgJsonToEditableOptions } = {
+  const { path: filepath, ...restOptions } = {
     __proto__: null,
     ...options
   };
-  const { normalize, ...normalizeOptions } = pkgJsonToEditableOptions;
+  const { normalize, ...normalizeOptions } = restOptions;
+  const EditablePackageJson = (0, import_edit_class.getEditablePackageJsonClass)();
   if (typeof filepath !== "string") {
-    return /* @__PURE__ */ pkgJsonToEditable(pkgJson, pkgJsonToEditableOptions);
+    return new EditablePackageJson().fromContent(
+      normalize ? (0, import_normalize2.normalizePackageJson)(pkgJson, normalizeOptions) : pkgJson
+    );
   }
-  const EditablePackageJson = /* @__PURE__ */ getEditablePackageJsonClass();
   const pkgJsonPath = (0, import_packages.resolvePackageJsonDirname)(filepath);
   return new EditablePackageJson().create(pkgJsonPath).fromJSON(
-    `${(0, import_primordials.JSONStringify)(
+    `${(0, import_json.JSONStringify)(
       normalize ? (0, import_normalize2.normalizePackageJson)(pkgJson, {
         ...(0, import_normalize.isNodeModules)(pkgJsonPath) ? {} : { preserve: ["repository"] },
         ...normalizeOptions
       }) : pkgJson,
-      null,
+      void 0,
       2
     )}
 `
@@ -350,7 +86,6 @@ function toEditablePackageJsonSync(pkgJson, options) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getEditablePackageJsonClass,
-  pkgJsonToEditable,
   toEditablePackageJson,
   toEditablePackageJsonSync
 });

package/dist/packages/exports.d.ts

@@ -1,67 +1,69 @@
 /**
- * @fileoverview Package exports field utilities.
+ * @file Package exports field utilities.
  */
 /**
  * Find types definition for a specific subpath in package exports.
  *
  * @example
- * ```typescript
- * const exports = { '.': { types: './dist/index.d.ts', import: './dist/index.js' } }
- * const types = findTypesForSubpath(exports, './dist/index.js')
- * // types === './dist/index.d.ts'
- * ```
+ *   ;```typescript
+ *   const exports = {
+ *     '.': { types: './dist/index.d.ts', import: './dist/index.js' },
+ *   }
+ *   const types = findTypesForSubpath(exports, './dist/index.js')
+ *   // types === './dist/index.d.ts'
+ *   ```
  */
 export declare function findTypesForSubpath(entryExports: unknown, subpath: string): string | undefined;
 /**
  * Get file paths from package exports.
  *
  * @example
- * ```typescript
- * const exports = { '.': './dist/index.js', './utils': './dist/utils.js' }
- * getExportFilePaths(exports) // ['./dist/index.js', './dist/utils.js']
- * ```
+ *   ;```typescript
+ *   const exports = { '.': './dist/index.js', './utils': './dist/utils.js' }
+ *   getExportFilePaths(exports) // ['./dist/index.js', './dist/utils.js']
+ *   ```
  */
 export declare function getExportFilePaths(entryExports: unknown): string[];
 /**
  * Get subpaths from package exports.
  *
  * @example
- * ```typescript
- * const exports = { '.': './index.js', './utils': './utils.js' }
- * getSubpaths(exports) // ['.', './utils']
- * ```
+ *   ;```typescript
+ *   const exports = { '.': './index.js', './utils': './utils.js' }
+ *   getSubpaths(exports) // ['.', './utils']
+ *   ```
  */
 export declare function getSubpaths(entryExports: unknown): string[];
 /**
  * Check if package exports use conditional patterns (e.g., import/require).
  *
  * @example
- * ```typescript
- * isConditionalExports({ import: './index.mjs', require: './index.cjs' }) // true
- * isConditionalExports({ '.': './index.js' })                            // false
- * ```
+ *   ;```typescript
+ *   isConditionalExports({ import: './index.mjs', require: './index.cjs' }) // true
+ *   isConditionalExports({ '.': './index.js' }) // false
+ *   ```
  */
 export declare function isConditionalExports(entryExports: unknown): boolean;
 /**
  * Check if package exports use subpath patterns (keys starting with '.').
  *
  * @example
- * ```typescript
- * isSubpathExports({ '.': './index.js', './utils': './utils.js' }) // true
- * isSubpathExports({ import: './index.mjs' })                     // false
- * ```
+ *   ;```typescript
+ *   isSubpathExports({ '.': './index.js', './utils': './utils.js' }) // true
+ *   isSubpathExports({ import: './index.mjs' }) // false
+ *   ```
  */
 export declare function isSubpathExports(entryExports: unknown): boolean;
 /**
  * Normalize package.json exports field to canonical format.
  *
  * @example
- * ```typescript
- * resolvePackageJsonEntryExports('./index.js')
- * // { '.': './index.js' }
+ *   ;```typescript
+ *   resolvePackageJsonEntryExports('./index.js')
+ *   // { '.': './index.js' }
  *
- * resolvePackageJsonEntryExports({ '.': './index.js' })
- * // { '.': './index.js' }
- * ```
+ *   resolvePackageJsonEntryExports({ '.': './index.js' })
+ *   // { '.': './index.js' }
+ *   ```
  */
 export declare function resolvePackageJsonEntryExports(entryExports: unknown): unknown;