@socketsecurity/lib 0.0.0 → 1.0.0

package/dist/json.js

@@ -0,0 +1,75 @@
+/* Socket Lib - Built with esbuild */
+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 json_exports = {};
+__export(json_exports, {
+  isJsonPrimitive: () => isJsonPrimitive,
+  jsonParse: () => jsonParse
+});
+module.exports = __toCommonJS(json_exports);
+var import_strings = require("./strings");
+const JSONParse = JSON.parse;
+// @__NO_SIDE_EFFECTS__
+function isBuffer(x) {
+  if (!x || typeof x !== "object") {
+    return false;
+  }
+  const obj = x;
+  if (typeof obj["length"] !== "number") {
+    return false;
+  }
+  if (typeof obj["copy"] !== "function" || typeof obj["slice"] !== "function") {
+    return false;
+  }
+  if (typeof obj["length"] === "number" && obj["length"] > 0 && typeof obj[0] !== "number") {
+    return false;
+  }
+  const Ctor = x.constructor;
+  return !!(typeof Ctor?.isBuffer === "function" && Ctor.isBuffer(x));
+}
+// @__NO_SIDE_EFFECTS__
+function isJsonPrimitive(value) {
+  return value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string";
+}
+// @__NO_SIDE_EFFECTS__
+function jsonParse(content, options) {
+  const { filepath, reviver, throws } = {
+    __proto__: null,
+    ...options
+  };
+  const shouldThrow = throws === void 0 || !!throws;
+  const jsonStr = /* @__PURE__ */ isBuffer(content) ? content.toString("utf8") : content;
+  try {
+    return JSONParse((0, import_strings.stripBom)(jsonStr), reviver);
+  } catch (e) {
+    if (shouldThrow) {
+      const error = e;
+      if (error && typeof filepath === "string") {
+        error.message = `${filepath}: ${error.message}`;
+      }
+      throw error;
+    }
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isJsonPrimitive,
+  jsonParse
+});
+//# sourceMappingURL=json.js.map

package/dist/json.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/json.ts"],
+  "sourcesContent": ["/**\n * @fileoverview JSON parsing utilities with Buffer detection and BOM stripping.\n * Provides safe JSON parsing with automatic encoding handling.\n */\n\nimport { stripBom } from './strings'\n\nexport type JsonPrimitive = null | boolean | number | string\n\nexport type JsonValue = JsonPrimitive | JsonObject | JsonArray\n\nexport interface JsonObject {\n  [key: string]: JsonValue\n}\n\nexport interface JsonArray extends Array<JsonValue> {}\n\nexport type JsonReviver = (key: string, value: unknown) => unknown\n\nexport interface JsonParseOptions {\n  filepath?: string\n  reviver?: JsonReviver | undefined\n  throws?: boolean\n}\n\n// IMPORTANT: Do not use destructuring here - use direct assignment instead.\n// tsgo has a bug that incorrectly transpiles destructured exports, resulting in\n// `exports.SomeName = void 0;` which causes runtime errors.\n// See: https://github.com/SocketDev/socket-packageurl-js/issues/3\nconst JSONParse = JSON.parse\n\n/**\n * Check if a value is a Buffer instance.\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction isBuffer(x: unknown): x is Buffer {\n  if (!x || typeof x !== 'object') {\n    return false\n  }\n  const obj = x as Record<string | number, unknown>\n  if (typeof obj['length'] !== 'number') {\n    return false\n  }\n  if (typeof obj['copy'] !== 'function' || typeof obj['slice'] !== 'function') {\n    return false\n  }\n  if (\n    typeof obj['length'] === 'number' &&\n    obj['length'] > 0 &&\n    typeof obj[0] !== 'number'\n  ) {\n    return false\n  }\n\n  const Ctor = (x as { constructor?: unknown }).constructor as\n    | { isBuffer?: unknown }\n    | undefined\n  return !!(typeof Ctor?.isBuffer === 'function' && Ctor.isBuffer(x))\n}\n\n/**\n * Check if a value is a JSON primitive (null, boolean, number, or string).\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function isJsonPrimitive(value: unknown): value is JsonPrimitive {\n  return (\n    value === null ||\n    typeof value === 'boolean' ||\n    typeof value === 'number' ||\n    typeof value === 'string'\n  )\n}\n\n/**\n * Parse JSON content with error handling and BOM stripping.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function jsonParse(\n  content: string | Buffer,\n  options?: JsonParseOptions | undefined,\n): JsonValue | undefined {\n  const { filepath, reviver, throws } = {\n    __proto__: null,\n    ...options,\n  } as JsonParseOptions\n  const shouldThrow = throws === undefined || !!throws\n  const jsonStr = isBuffer(content) ? content.toString('utf8') : content\n  try {\n    return JSONParse(stripBom(jsonStr), reviver)\n  } catch (e) {\n    if (shouldThrow) {\n      const error = e as Error\n      if (error && typeof filepath === 'string') {\n        error.message = `${filepath}: ${error.message}`\n      }\n      throw error\n    }\n  }\n  return undefined\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,qBAAyB;AAwBzB,MAAM,YAAY,KAAK;AAAA;AAMvB,SAAS,SAAS,GAAyB;AACzC,MAAI,CAAC,KAAK,OAAO,MAAM,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,QAAM,MAAM;AACZ,MAAI,OAAO,IAAI,QAAQ,MAAM,UAAU;AACrC,WAAO;AAAA,EACT;AACA,MAAI,OAAO,IAAI,MAAM,MAAM,cAAc,OAAO,IAAI,OAAO,MAAM,YAAY;AAC3E,WAAO;AAAA,EACT;AACA,MACE,OAAO,IAAI,QAAQ,MAAM,YACzB,IAAI,QAAQ,IAAI,KAChB,OAAO,IAAI,CAAC,MAAM,UAClB;AACA,WAAO;AAAA,EACT;AAEA,QAAM,OAAQ,EAAgC;AAG9C,SAAO,CAAC,EAAE,OAAO,MAAM,aAAa,cAAc,KAAK,SAAS,CAAC;AACnE;AAAA;AAMO,SAAS,gBAAgB,OAAwC;AACtE,SACE,UAAU,QACV,OAAO,UAAU,aACjB,OAAO,UAAU,YACjB,OAAO,UAAU;AAErB;AAAA;AAMO,SAAS,UACd,SACA,SACuB;AACvB,QAAM,EAAE,UAAU,SAAS,OAAO,IAAI;AAAA,IACpC,WAAW;AAAA,IACX,GAAG;AAAA,EACL;AACA,QAAM,cAAc,WAAW,UAAa,CAAC,CAAC;AAC9C,QAAM,UAAU,yBAAS,OAAO,IAAI,QAAQ,SAAS,MAAM,IAAI;AAC/D,MAAI;AACF,WAAO,cAAU,yBAAS,OAAO,GAAG,OAAO;AAAA,EAC7C,SAAS,GAAG;AACV,QAAI,aAAa;AACf,YAAM,QAAQ;AACd,UAAI,SAAS,OAAO,aAAa,UAAU;AACzC,cAAM,UAAU,GAAG,QAAQ,KAAK,MAAM,OAAO;AAAA,MAC/C;AACA,YAAM;AAAA,IACR;AAAA,EACF;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/logger.d.ts

@@ -0,0 +1,183 @@
+// Type definitions
+type LogSymbols = {
+    fail: string;
+    info: string;
+    success: string;
+    warn: string;
+};
+type LoggerMethods = {
+    [K in keyof typeof console]: (typeof console)[K] extends (...args: infer A
+    // biome-ignore lint/suspicious/noExplicitAny: Console method return types are dynamic.
+    ) => any ? (...args: A) => Logger : (typeof console)[K];
+};
+interface Task {
+    run<T>(f: () => T): T;
+}
+export type { LogSymbols, LoggerMethods, Task };
+export declare const LOG_SYMBOLS: Record<string, string>;
+export declare const incLogCallCountSymbol: unique symbol;
+export declare const lastWasBlankSymbol: unique symbol;
+/**
+ * Custom Logger class that wraps console with additional features.
+ * Supports indentation, symbols, and blank line tracking.
+ */
+/*@__PURE__*/
+export declare class Logger {
+    #private;
+    static LOG_SYMBOLS: Record<string, string>;
+    constructor(...args: unknown[]);
+    /**
+     * Get a logger instance bound to stderr.
+     * All operations on this instance will use stderr.
+     */
+    get stderr(): Logger;
+    /**
+     * Get a logger instance bound to stdout.
+     * All operations on this instance will use stdout.
+     */
+    get stdout(): Logger;
+    /**
+     * Get the current log call count.
+     */
+    get logCallCount(): number;
+    /**
+     * Increment the log call count.
+     */
+    [incLogCallCountSymbol](): this;
+    /**
+     * Set whether the last logged line was blank.
+     */
+    [lastWasBlankSymbol](value: unknown): this;
+    /**
+     * Log an assertion.
+     */
+    assert(value: unknown, ...message: unknown[]): this;
+    /**
+     * Clear the visible terminal screen.
+     * Only available on the main logger instance.
+     */
+    clearVisible(): this;
+    /**
+     * Log a count for the given label.
+     */
+    count(label?: string): this;
+    /**
+     * Create a task with a given name.
+     */
+    createTask(name: string): Task;
+    /**
+     * Decrease indentation level.
+     * If called on main logger, affects both streams.
+     * If called on stream-bound logger, affects only that stream.
+     */
+    dedent(spaces?: number): this;
+    /**
+     * Display an object's properties.
+     */
+    dir(obj: unknown, options?: unknown): this;
+    /**
+     * Display data as XML.
+     */
+    dirxml(...data: unknown[]): this;
+    /**
+     * Log an error message.
+     */
+    error(...args: unknown[]): this;
+    /**
+     * Log a newline to stderr if last line wasn't blank.
+     */
+    errorNewline(): this;
+    /**
+     * Log a failure message with symbol.
+     */
+    fail(...args: unknown[]): this;
+    /**
+     * Start a new log group.
+     */
+    group(...label: unknown[]): this;
+    /**
+     * Start a new collapsed log group (alias for group).
+     */
+    // groupCollapsed is an alias of group.
+    // https://nodejs.org/api/console.html#consolegroupcollapsed
+    groupCollapsed(...label: unknown[]): this;
+    /**
+     * End the current log group.
+     */
+    groupEnd(): this;
+    /**
+     * Increase indentation level.
+     * If called on main logger, affects both streams.
+     * If called on stream-bound logger, affects only that stream.
+     */
+    indent(spaces?: number): this;
+    /**
+     * Log an info message with symbol.
+     */
+    info(...args: unknown[]): this;
+    /**
+     * Log a message.
+     */
+    log(...args: unknown[]): this;
+    /**
+     * Log a newline to stdout if last line wasn't blank.
+     */
+    logNewline(): this;
+    /**
+     * Reset indentation to zero.
+     * If called on main logger, resets both streams.
+     * If called on stream-bound logger, resets only that stream.
+     */
+    resetIndent(): this;
+    /**
+     * Log a main step with blank line before (stateless).
+     */
+    step(msg: string, ...extras: unknown[]): this;
+    /**
+     * Log an indented substep (stateless).
+     */
+    substep(msg: string, ...extras: unknown[]): this;
+    /**
+     * Log a success message with symbol.
+     */
+    success(...args: unknown[]): this;
+    /**
+     * Log a done message (alias for success).
+     * Does NOT auto-clear. Call clearLine() first if needed after progress().
+     */
+    done(...args: unknown[]): this;
+    /**
+     * Display data in a table format.
+     */
+    table(tabularData: unknown, properties?: readonly string[]): this;
+    /**
+     * End a timer and log the elapsed time.
+     */
+    timeEnd(label?: string): this;
+    /**
+     * Log the current timer value.
+     */
+    timeLog(label?: string, ...data: unknown[]): this;
+    /**
+     * Log a stack trace.
+     */
+    trace(message?: unknown, ...args: unknown[]): this;
+    /**
+     * Log a warning message with symbol.
+     */
+    warn(...args: unknown[]): this;
+    /**
+     * Write to stdout without a newline or indentation.
+     */
+    write(text: string): this;
+    /**
+     * Show a progress indicator (can be cleared with clearLine).
+     * Simple status message without spinner animation.
+     */
+    progress(text: string): this;
+    /**
+     * Clear the current line.
+     */
+    clearLine(): this;
+}
+export declare const logger: Logger;