data-structure-typed 2.4.0 → 2.4.2

package/test/utils/big-o.ts

@@ -1,228 +0,0 @@
-import { AnyFunction } from '../types';
-import { isDebugTest } from '../config';
-
-const isDebug = isDebugTest;
-// const orderReducedBy = 1; // reduction of bigO's order compared to the baseline bigO
-
-export const magnitude = {
-  // CONSTANT: Math.pow(10, 9),
-  // LOG_N: Math.pow(10, 8 - orderReducedBy),
-  // LINEAR: Math.pow(10, 7 - orderReducedBy),
-  // N_LOG_N: Math.pow(10, 4 - orderReducedBy),
-  // SQUARED: Math.pow(10, 3 - orderReducedBy),
-  // CUBED: Math.pow(10, 2 - orderReducedBy),
-  // FACTORIAL: 20 - orderReducedBy,
-  THOUSAND: 1000,
-  TEN_THOUSAND: 10000,
-  HUNDRED_THOUSAND: 100000,
-  MILLION: 1000000,
-  TEN_MILLION: 10000000,
-  BILLION: 100000000
-};
-
-export const bigO = {
-  // CONSTANT: magnitude.CONSTANT / 100000,
-  // LOG_N: Math.log2(magnitude.LOG_N) / 1000,
-  // LINEAR: magnitude.LINEAR / 1000,
-  // N_LOG_N: (magnitude.N_LOG_N * Math.log2(magnitude.LOG_N)) / 1000,
-  // SQUARED: Math.pow(magnitude.SQUARED, 2) / 1000,
-  // CUBED: Math.pow(magnitude.SQUARED, 3) / 1000,
-  FACTORIAL: 10000
-};
-
-function findPotentialN(input: any): number {
-  let longestArray: any[] = [];
-  let mostProperties: {
-    [key: string]: any;
-  } = {};
-
-  function recurse(obj: any) {
-    if (Array.isArray(obj)) {
-      if (obj.length > longestArray.length) {
-        longestArray = obj;
-      }
-    } else if (typeof obj === 'object' && obj !== null) {
-      const keys = Object.keys(obj);
-      if (keys.length > Object.keys(mostProperties).length) {
-        mostProperties = obj;
-      }
-      keys.forEach(key => {
-        recurse(obj[key]);
-      });
-    }
-  }
-
-  if (Array.isArray(input)) {
-    input.forEach(item => {
-      recurse(item);
-    });
-  } else {
-    recurse(input);
-  }
-
-  // return [longestArray, mostProperties] : [any[], { [key: string]: any }];
-  return Math.max(longestArray.length, Object.keys(mostProperties).length);
-}
-
-function linearRegression(x: number[], y: number[]) {
-  const n = x.length;
-
-  const sumX = x.reduce((acc, value) => acc + value, 0);
-  const sumY = y.reduce((acc, value) => acc + value, 0);
-
-  const sumXSquared = x.reduce((acc, value) => acc + value ** 2, 0);
-  const sumXY = x.reduce((acc, value, i) => acc + value * y[i], 0);
-
-  const slope = (n * sumXY - sumX * sumY) / (n * sumXSquared - sumX ** 2);
-  const intercept = (sumY - slope * sumX) / n;
-
-  const yHat = x.map(value => slope * value + intercept);
-
-  const totalVariation = y.map((value, i) => (value - yHat[i]) ** 2).reduce((acc, value) => acc + value, 0);
-  const explainedVariation = y.map(value => (value - sumY / n) ** 2).reduce((acc, value) => acc + value, 0);
-
-  const rSquared = 1 - totalVariation / explainedVariation;
-
-  return { slope, intercept, rSquared };
-}
-
-function estimateBigO(runtimes: number[], dataSizes: number[]): string {
-  // Make sure the input runtimes and data sizes have the same length
-  if (runtimes.length !== dataSizes.length) {
-    return 'Lengths of input arrays do not match';
-  }
-
-  // Create an array to store the computational complexity of each data point
-  const complexities: string[] = [];
-
-  // Traverse different possible complexities
-  const complexitiesToCheck: string[] = [
-    'O(1)', // constant time complexity
-    'O(log n)', // Logarithmic time complexity
-    'O(n)', // linear time complexity
-    'O(n log n)', // linear logarithmic time complexity
-    'O(n^2)' // squared time complexity
-  ];
-
-  for (const complexity of complexitiesToCheck) {
-    // Calculate data points for fitting
-    const fittedData: number[] = dataSizes.map(size => {
-      if (complexity === 'O(1)') {
-        return 1; // constant time complexity
-      } else if (complexity === 'O(log n)') {
-        return Math.log(size);
-      } else if (complexity === 'O(n)') {
-        return size;
-      } else if (complexity === 'O(n log n)') {
-        return size * Math.log(size);
-      } else if (complexity === 'O(n^2)') {
-        return size ** 2;
-      } else {
-        return size ** 10;
-      }
-    });
-
-    // Fit the data points using linear regression analysis
-    const regressionResult = linearRegression(fittedData, runtimes);
-
-    // Check the R-squared value of the fit. It is usually considered a valid fit if it is greater than 0.9.
-    if (regressionResult.rSquared >= 0.9) {
-      complexities.push(complexity);
-    }
-  }
-
-  // If there is no valid fitting result, return "cannot estimate", otherwise return the estimated time complexity
-  if (complexities.length === 0) {
-    return 'Unable to estimate';
-  } else {
-    return complexities.join(' or ');
-  }
-}
-
-const methodLogs: Map<string, [number, number][]> = new Map();
-
-export function logBigOMetricsWrap<F extends AnyFunction>(fn: F, args: Parameters<F>, fnName: string) {
-  const startTime = performance.now();
-  const result = fn(args);
-  const endTime = performance.now();
-  const runTime = endTime - startTime;
-  const methodName = `${fnName}`;
-  if (!methodLogs.has(methodName)) {
-    methodLogs.set(methodName, []);
-  }
-
-  const methodLog = methodLogs.get(methodName);
-
-  const maxDataSize = args.length === 1 && typeof args[0] === 'number' ? args[0] : findPotentialN(args);
-  if (methodLog) {
-    methodLog.push([runTime, maxDataSize]);
-
-    if (methodLog.length >= 20) {
-      if (isDebug) console.log('triggered', methodName, methodLog);
-      const bigO = estimateBigO(
-        methodLog.map(([runTime]) => runTime),
-        methodLog.map(([runTime]) => runTime)
-      );
-      if (isDebug) console.log(`Estimated Big O: ${bigO}`);
-      methodLogs.delete(methodName);
-    }
-  }
-
-  return result;
-}
-
-export function logBigOMetrics(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-  const originalMethod = descriptor.value;
-
-  descriptor.value = function (...args: any[]) {
-    const startTime = performance.now();
-    const result = originalMethod.apply(this, args);
-    const endTime = performance.now();
-    const runTime = endTime - startTime;
-
-    const methodName = `${target.constructor.name}.${propertyKey}`;
-    if (!methodLogs.has(methodName)) {
-      methodLogs.set(methodName, []);
-    }
-
-    const methodLog = methodLogs.get(methodName);
-
-    const maxDataSize = args.length === 1 && typeof args[0] === 'number' ? args[0] : findPotentialN(args);
-    if (methodLog) {
-      methodLog.push([runTime, maxDataSize]);
-
-      if (methodLog.length >= 20) {
-        if (isDebug) console.log('triggered', methodName, methodLog);
-        const bigO = estimateBigO(
-          methodLog.map(([runTime]) => runTime),
-          methodLog.map(([runTime]) => runTime)
-        );
-
-        if (isDebug) console.log(`Estimated Big O: ${bigO}`);
-        methodLogs.delete(methodName);
-      }
-    }
-
-    return result;
-  };
-
-  return descriptor;
-}
-
-export const logPerf = function (
-  label: string = 'function running cost',
-  fn: (...args: any[]) => any,
-  args: any[],
-  thisArg?: any
-) {
-  const start = performance.now();
-  let result: any;
-  if (thisArg) {
-    if (args && args.length > 0) result = fn.apply(thisArg, args);
-    else result = fn.apply(thisArg);
-  } else {
-    if (args && args.length > 0) result = fn(...args);
-    else result = fn();
-  }
-  console.log(`${(performance.now() - start).toFixed(2)} ms, ${label}, ${result}`);
-};

package/test/utils/console.ts

@@ -1,31 +0,0 @@
-export const ConsoleColor = {
-  END: '\x1b[0m',
-  BOLD: '\x1b[1m',
-  DIM: '\x1b[2m',
-  ITALIC: '\x1b[3m',
-  UNDERLINE: '\x1b[4m',
-  INVERSE: '\x1b[7m',
-  STRIKETHROUGH: '\x1b[9m',
-  NO_BOLD: '\x1b[22m',
-  NO_ITALIC: '\x1b[23m',
-  NO_UNDERLINE: '\x1b[24m',
-  NO_INVERSE: '\x1b[27m',
-  NO_STRIKETHROUGH: '\x1b[29m',
-  BLACK: '\x1b[30m',
-  RED: '\x1b[31m',
-  GREEN: '\x1b[32m',
-  YELLOW: '\x1b[33m',
-  BLUE: '\x1b[34m',
-  MAGENTA: '\x1b[35m',
-  GRAY: '\x1b[90m',
-  CYAN: '\x1b[36m',
-  WHITE: '\x1b[37m',
-  BG_BLACK: '\x1b[40m',
-  BG_RED: '\x1b[41m',
-  BG_GREEN: '\x1b[42m',
-  BG_YELLOW: '\x1b[43m',
-  BG_BLUE: '\x1b[44m',
-  BG_MAGENTA: '\x1b[45m',
-  BG_CYAN: '\x1b[46m',
-  BG_WHITE: '\x1b[47m'
-};

package/test/utils/index.ts

@@ -1,8 +0,0 @@
-export * from './number';
-export * from './array';
-export * from './big-o';
-export * from './json2html';
-export * from './is';
-export * from './console';
-export * from './string';
-export * from './performanc';

package/test/utils/is.ts

@@ -1,56 +0,0 @@
-export const isNumber = (value: any) => {
-  return typeof value === 'number';
-};
-export const isString = (value: any) => {
-  return typeof value === 'string';
-};
-export const isBoolean = (value: any) => {
-  return typeof value === 'boolean';
-};
-export const isDate = (value: any) => {
-  return value instanceof Date;
-};
-export const isNull = (value: any) => {
-  return value === null;
-};
-export const isUndefined = (value: any) => {
-  return typeof value === 'undefined';
-};
-export const isFunction = (value: any) => {
-  return typeof value === 'function';
-};
-export const isObject = (value: any) => {
-  return typeof value === 'object';
-};
-export const isArray = (value: any) => {
-  return Array.isArray(value);
-};
-
-export const isEqual = (objA: any, objB: any): boolean => {
-  if (objA === objB) {
-    return true;
-  }
-
-  if (typeof objA !== 'object' || typeof objB !== 'object' || objA === null || objB === null) {
-    return false;
-  }
-
-  const keysA = Object.keys(objA);
-  const keysB = Object.keys(objB);
-
-  if (keysA.length !== keysB.length) {
-    return false;
-  }
-
-  for (const key of keysA) {
-    if (!keysB.includes(key)) {
-      return false;
-    }
-
-    if (!isEqual(objA[key], objB[key])) {
-      return false;
-    }
-  }
-
-  return true;
-};

package/test/utils/json2html.ts

@@ -1,164 +0,0 @@
-import * as _ from './is';
-import { Json2htmlOptions } from '../types';
-
-function toggleJS(options?: Json2htmlOptions): string {
-  if (options?.plainHtml) {
-    return '';
-  } else {
-    return 'onclick="json-to-html.toggleVisibility(this);return false"';
-  }
-}
-
-function makeLabelDiv(options: any, level: number, keyName: string | number, datatype?: string): string {
-  if (typeof keyName === 'number') {
-    return `<div class='index'><span class='json-to-html-label'>${keyName}&nbsp;</span></div>`;
-  } else if (typeof keyName === 'string') {
-    if (datatype === 'array') {
-      return `<div class='collapsible level${level}' ${toggleJS(options)}><span class='json-to-html-label'>${keyName}</span></div>`;
-    } else if (datatype === 'object') {
-      return `<div class='attribute collapsible level${level}' ${toggleJS(options)}><span class='json-to-html-label'>${keyName}:</span></div>`;
-    } else {
-      return `<div class='leaf level${level}'><span class='json-to-html-label'>${keyName}:</span></div>`;
-    }
-  } else {
-    return '';
-  }
-}
-
-function getContentClass(keyName: string | number): string {
-  if (typeof keyName === 'string') {
-    return 'content';
-  } else {
-    return '';
-  }
-}
-
-function isPlainObject(val: any): boolean {
-  let lastKey: string | undefined;
-  let lastOwnKey: string | undefined;
-  for (const key in val) {
-    if (val.hasOwnProperty(key)) {
-      lastOwnKey = key;
-    }
-  }
-  for (const key in val) {
-    lastKey = key;
-  }
-  return lastOwnKey === lastKey;
-}
-
-function isLeafValue(val: any): boolean {
-  return (
-    _.isNumber(val) ||
-    _.isString(val) ||
-    _.isBoolean(val) ||
-    _.isDate(val) ||
-    _.isNull(val) ||
-    _.isUndefined(val) ||
-    isNaN(val) ||
-    _.isFunction(val) ||
-    !isPlainObject(val)
-  );
-}
-
-function isLeafObject(obj: any): boolean {
-  if (!_.isObject(obj)) {
-    return false;
-  }
-  for (const key in obj) {
-    const val = obj[key];
-    if (!isLeafValue(val)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function isTable(arr: any[]): boolean {
-  if (!_.isArray(arr)) {
-    return false;
-  }
-  if (arr.length === 0 || !_.isObject(arr[0])) {
-    return false;
-  } else {
-    let nonCompliant = arr.find(row => !isLeafObject(row));
-    if (nonCompliant) {
-      return false;
-    } else {
-      const cols = Object.keys(arr[0]);
-      nonCompliant = arr.find((row: object) => !_.isEqual(cols, Object.keys(row)));
-      if (nonCompliant) {
-        return false;
-      } else {
-        return true;
-      }
-    }
-  }
-}
-
-function drawTable(arr: any[]): string {
-  function drawRow(headers: string[], rowObj: any): string {
-    return '<td>' + headers.map(header => rowObj[header]).join('</td><td>') + '</td>';
-  }
-
-  const cols = Object.keys(arr[0]);
-  const content = arr.map(rowObj => drawRow(cols, rowObj));
-  const headingHtml = '<tr><th>' + cols.join('</th><th>') + '</th></tr>';
-  const contentHtml = '<tr>' + content.join('</tr><tr>') + '</tr>';
-  return '<table style="display: table; width:100%; table-layout: fixed;">' + headingHtml + contentHtml + '</table>';
-}
-
-function _render(name: string, data: any, options: Json2htmlOptions, level: number, altRow: number): string {
-  const contentClass = getContentClass(name);
-  if (_.isArray(data)) {
-    const title = makeLabelDiv(options, level, `${name}`, 'array');
-    let subs: string;
-    if (isTable(data)) {
-      subs = drawTable(data);
-    } else {
-      subs =
-        "<div class='altRows'>" +
-        data
-          .map((val: any, idx: number) => _render(idx.toString(), val, options, level + 1, idx % 2))
-          .join("</div><div class='altRows'>") +
-        '</div>';
-    }
-    return `<div class="json-to-html-collapse clearfix ${altRow}">
-      ${title}
-      <div class="${contentClass}">${subs}</div>
-    </div>`;
-  } else if (isLeafValue(data)) {
-    const title = makeLabelDiv(options, level, name);
-    if (_.isFunction(data)) {
-      return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;-function() can't _render-</span>`;
-    } else if (!isPlainObject(data)) {
-      if (_.isFunction(data.toString)) {
-        return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;${data.toString()}</span>`;
-      } else {
-        return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;-instance object, can't render-</span>`;
-      }
-    } else {
-      return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;${data}</span>`;
-    }
-  } else {
-    const title = makeLabelDiv(options, level, name, 'object');
-    let count = 0;
-    const subs =
-      '<div>' +
-      Object.entries(data)
-        .map(([key, val]) => _render(key, val, options, level + 1, count++ % 2))
-        .join('</div><div>') +
-      '</div>';
-    const inner = `<div class="json-to-html-expand clearfix ${altRow}">
-      ${title}
-      <div class="${contentClass}">${subs}</div>
-    </div>`;
-    return `${level === 0 ? "<div id='json-to-html'>" : ''}
-      ${inner}
-      ${level === 0 ? '</div>' : ''}`;
-  }
-}
-
-export function render(name: string, json: any, options: Json2htmlOptions): string {
-  return `${_render(name, json, options, 0, 0)}`;
-}

package/test/utils/number.ts

@@ -1,13 +0,0 @@
-export function getRandomInt(min: number = 0, max: number = 1000) {
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
-export function numberFix(num: number, decimalPlaces: number): string {
-  if (num > 10000 || num < 0.001) {
-    const [mantissa, exponent] = num.toExponential().split('e');
-    const formattedMantissa = Number(mantissa).toFixed(decimalPlaces);
-    return `${formattedMantissa}e${exponent}`;
-  } else {
-    return num.toFixed(decimalPlaces);
-  }
-}

package/test/utils/patch.ts

@@ -1,33 +0,0 @@
-export async function withMutedConsole<T>(fn: () => T | Promise<T>): Promise<T> {
-  const originalLog = console.log;
-  const originalWarn = console.warn;
-  const originalError = console.error;
-
-  // Keep it minimal: silence during the callback, always restore.
-  console.log = (_message?: any, ..._optionalParams: any[]) => undefined;
-  console.warn = (_message?: any, ..._optionalParams: any[]) => undefined;
-  console.error = (_message?: any, ..._optionalParams: any[]) => undefined;
-
-  try {
-    return await fn();
-  } finally {
-    console.log = originalLog;
-    console.warn = originalWarn;
-    console.error = originalError;
-  }
-}
-
-export function withPatched<T extends object, K extends keyof T, R>(
-  obj: T,
-  key: K,
-  value: T[K],
-  fn: () => R
-): R {
-  const original = obj[key];
-  (obj as any)[key] = value;
-  try {
-    return fn();
-  } finally {
-    (obj as any)[key] = original;
-  }
-}

package/test/utils/perf.mjs

@@ -1,34 +0,0 @@
-// Re-export utilities for performance tests (ESM)
-export const magnitude = {
-  MILLION: 1000000,
-  HUNDRED_THOUSAND: 100000,
-  TEN_THOUSAND: 10000,
-  THOUSAND: 1000,
-  HUNDRED: 100
-};
-
-export function getRandomInt(min = 0, max = 1000) {
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
-export function getRandomIntArray(length, min = 0, max = 1000) {
-  return Array.from({ length }, () => getRandomInt(min, max));
-}
-
-export function getRandomIndex(length) {
-  return Math.floor(Math.random() * length);
-}
-
-export function getRandomWords(count, minLength = 3, maxLength = 10) {
-  const words = [];
-  const chars = 'abcdefghijklmnopqrstuvwxyz';
-  for (let i = 0; i < count; i++) {
-    const length = getRandomInt(minLength, maxLength);
-    let word = '';
-    for (let j = 0; j < length; j++) {
-      word += chars[Math.floor(Math.random() * chars.length)];
-    }
-    words.push(word);
-  }
-  return words;
-}

package/test/utils/performanc.ts

@@ -1,7 +0,0 @@
-import { performance } from 'perf_hooks';
-
-export const calcRunTime = (callback: (...args: any[]) => any) => {
-  const startTime = performance.now();
-  callback();
-  return performance.now() - startTime;
-};

package/test/utils/string.ts

@@ -1,49 +0,0 @@
-/**
- * Convert any string to CamelCase format
- */
-export function toCamelCase(str: string): string {
-  return str.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase());
-}
-
-/**
- * Convert any string to SnakeCase format
- */
-export function toSnakeCase(str: string): string {
-  return str
-    .replace(/([a-z])([A-Z])/g, '$1_$2') // Add underline between lowercase and uppercase letters
-    .toLowerCase() // Convert to lowercase
-    .replace(/[^a-z0-9]+/g, '_'); // Replace non-alphanumeric characters with underscores
-}
-
-/**
- * Convert any string to PascalCase format (first letter capitalized)
- */
-export function toPascalCase(str: string): string {
-  return str
-    .replace(/([a-z])([A-Z])/g, '$1 $2') // Add space between lowercase and uppercase letters
-    .replace(/[^a-zA-Z0-9]+/g, ' ') // Replace non-alphanumeric characters with spaces
-    .split(' ') // Separate strings by spaces
-    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()) // The first letter is capitalized, the rest are lowercase
-    .join(''); // Combine into a string
-}
-
-/**
- * Convert CamelCase or SnakeCase string to string format with specified separator
- */
-export function toSeparatedCase(str: string, separator: string = '_'): string {
-  return str
-    .replace(/([a-z0-9])([A-Z])/g, '$1' + separator + '$2')
-    .replace(/[_\s]+/g, separator)
-    .toLowerCase();
-}
-
-/**
- * Convert the string to all uppercase and delimit it using the specified delimiter
- */
-export function toUpperSeparatedCase(str: string, separator: string = '_'): string {
-  return str
-    .toUpperCase() // Convert all letters to uppercase
-    .replace(/([a-z0-9])([A-Z])/g, '$1' + separator + '$2') // Add separator between lowercase letters and uppercase letters
-    .replace(/[^A-Z0-9]+/g, separator) // Replace non-alphanumeric characters with separators
-    .replace(new RegExp(`^${separator}|${separator}$`, 'g'), ''); // Remove the starting and ending separators
-}

package/tsconfig.types.json

@@ -1,15 +0,0 @@
-{
-  "extends": "./tsconfig.base.json",
-  "compilerOptions": {
-    "target": "ES2018",
-    "lib": ["ES2018", "DOM"],
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "declaration": true,
-    "emitDeclarationOnly": true,
-    "declarationMap": false,
-    "outDir": "dist/types"
-  },
-  "include": ["./src/**/*.ts"],
-  "exclude": ["dist", "node_modules", "test"]
-}