dphelper 2.6.3 → 3.0.0

package/types/dphelper.d.ts

@@ -5,568 +5,168 @@
   https://dario.passariello.ca
 */
 
-////////////////////
-// Global object
-////////////////////
+declare global {
 
-/**
-* @return dphelper Root.
-*/
-interface _dphelper {
-  /**
-   * Dynamic index signature for additional properties
-   * @private
-   */
-  [key: string]: any
-
-  /**
-   * Anchor manipulation utilities
-   */
-  anchor: {
-    /**
-     * Converts anchor tags to onClick events
-     * @param selector - CSS selector for target elements
-     */
-    toOnClick(selector: string): void
-  }
-
-  /**
-   * Array manipulation utilities
-   */
-  array: {
-    /**
-     * Finds an element in an array by key
-     * @param array - Input array to search
-     * @param key - Key to search for
-     * @returns Found element or undefined
-     */
-    find<T>(array: T[], key: any): T | any
-
-    /**
-     * Returns array with unique values
-     * @param array - Input array
-     * @returns New array with unique values
-     */
-    unique<T>(array: T[]): T[]
-
-    /**
-     * Deletes an element from array by key
-     * @param array - Input array
-     * @param key - Key to delete
-     */
-    delete<T>(array: T[], key: keyof T): void
-
-    /**
-     * Merges two arrays
-     * @param arrayA - First array
-     * @param arrayB - Second array
-     * @returns Merged array
-     */
-    merge<T>(arrayA: T[], arrayB: T[]): T[]
-
-    /**
-     * Merges two arrays based on a key
-     * @param arrayA - First array
-     * @param arrayB - Second array
-     * @param key - Key to merge on
-     * @returns Merged array
-     */
-    mergeByKey<T extends Record<string, any>>(arrayA: T[], arrayB: T[], key: keyof T): T[]
-
-    /**
-     * Sorts array in ascending order
-     * @param array - Input array
-     * @returns Sorted array
-     */
-    asc<T>(array: T[]): T[]
-
-    /**
-     * Sorts array in descending order
-     * @param array - Input array
-     * @returns Sorted array
-     */
-    desc<T>(array: T[]): T[]
-
-    /**
-     * Finds duplicate values in array
-     * @param array - Input array
-     * @returns Array of duplicate values
-     */
-    duplicates<T>(array: T[]): T[]
-
-    /**
-     * Returns even elements from array
-     * @param array - Input array
-     * @returns Array with even elements
-     */
-    even<T>(array: T[]): T[]
-
-    /**
-     * Returns odd elements from array
-     * @param array - Input array
-     * @returns Array with odd elements
-     */
-    odd<T>(array: T[]): T[]
-
-    /**
-     * Converts array to object
-     * @param array - Input array
-     * @returns Resulting object
-     */
-    toObj<T>(array: T[]): Record<string, T>
-
-    /**
-     * Sums values in a specific column of 2D array
-     * @param array - Input 2D array
-     * @param column - Column index to sum
-     * @returns Sum of values
-     */
-    sumColumn(array: number[][], column: number): number
-
-    /**
-     * Shuffles array elements randomly
-     * @param array - Input array
-     * @returns Shuffled array
-     */
-    shuffle<T>(array: T[]): T[]
-
-    /**
-     * Generates array with sequential numbers
-     * @param num - Length of array to generate
-     * @returns Generated array
-     */
-    generate(num: number): number[]
-
-    /**
-     * Tests if array contains only integers
-     * @param array - Input array
-     * @returns Array of valid integers
-     */
-    testArrayInt(array: unknown[]): number[]
-
-    /**
-     * Generates random 32-bit number
-     * @param number - Upper bound
-     * @returns Random number
-     */
-    rand32(number: number): number
-
-    /**
-     * Finds index of element by key
-     * @param array - Input array
-     * @param key - Key to search for
-     * @returns Found index or -1
-     */
-    findindex<T>(array: T[], key: any): number
-
-    /**
-     * Converts path array to JSON object
-     * @param array - Input array
-     * @param separator - Path separator
-     * @returns Resulting object
-     */
-    pathToJson(array: string[], separator?: string): Record<string, unknown>
-
-    /**
-     * Deep clones an object or array
-     * @param src - Source to clone
-     * @returns Cloned copy
-     */
-    deepClone<T>(src: T): T
-
-    /**
-     * Checks if arrays have matching elements
-     * @param arrayWords - Array of words to match
-     * @param arrayToCheck - Array to check against
-     * @returns Whether arrays match
-     */
-    match(arrayWords: string[], arrayToCheck: string[]): boolean
-  }
-
-  audio: {
-    play: (url: string) => void
+  interface Window {
+    dphelper: import("./dphelper")._dphelper
   }
 
-  avoid: {
-    cache: (uri: string) => string
+  interface SubCommand {
+    name: string
+    version: string
+    example: string
+    author: string
+    creationDate: string
+    lastMod: string
+    type: string
+    active: boolean
+    description: string
+    env?: "client" | "server" | "both"
+    subCommand: SubCommand[]
   }
 
-  browser: {
-    state(state: any, title: any, url: any): void
-    forw(times: number): void
-    back(times: number): void
-    reload(): void
-    href(url: string): void
-    offLine(text?: string): void
-    zoom(): number
-    status(code: number): string
+  interface Description {
+    name: string
+    active: boolean
+    subCommand: SubCommand[]
   }
 
-  check: {
-    url: (url: string) => any
-    version: (v1: string, v2: string, opts: any) => any
-    npmVer: (npm: string) => any
-  }
-
-  color: {
-    hex: (c: any) => string
-    toHex: (rgb: any) => string
-    toRGB: (c: any) => []
-    oleColor: (c: any) => string
-    gradient: (colorStart: any, colorEnd: any, colorCount: any) => any
-
-  }
-
-  console: {
-    info(name: string, message: string, fn: Function): void
-    stop(options?: string[]): void
-    toHtml(el: string): void
-  }
-
-  cookie: {
-    set: (pars: {
-      name: any,
-      value: any,
-      time?: any,
-      path?: "/",
-      sameSite?: "Lax",
-      secure?: "Secure" | "false"
-    }) => any
-    get: (name: string) => any
-    delete: (name: string) => any
-    removeAll: () => any
-  }
-
-  coords: {
-    degreesToRadians: (degrees: any) => any
-    latToMeters: (points: any) => any
-    toVector: (points: any) => any
-    convertToDecDegrees: (deg: any, minutes: any, sec: any, direction: any) => any
-    distance: (point1: any, point2: any) => any
-    polarToCartesian: (centerX: any, centerY: any, radius: any, angleInDegrees: any) => any
-    mapDegreesToPixels: (degree: number, minDegree: number, maxDegree: number, minPixel: number, maxPixel: number, padding: number) => number
-  }
-
-  date: {
-    days: (lang?: string) => string[]
-    months: (lang?: string) => string[]
-    year: () => number
-    toIso: (value: any, int?: string) => string | null
-    toMMDDYYYY: (value: any) => string
-    toYYYYMMDD: (value: any) => string | undefined
-    toHuman: (value: any) => string
-    convert: (value: any, format: string[]) => string | null
-    iso2Epoch: (value: any) => number
-    localIsoTime: (value: any) => string
-    utc: () => string
-    parse: (value: any, separator?: string) => string | null
-    addDays: (date: any, days: number) => Date
-    dateTimeToString: (dateObject: any) => string
-    isoToHuman: (value: any, symbol?: string) => string | null
-    fullDate: () => string
-    epoch: () => number
-    diffInDays: (d1: any, d2: any) => number
-    diffInWeeks: (d1: any, d2: any) => number
-    diffInMonths: (d1: any, d2: any) => number
-    diffInYears: (d1: any, d2: any) => number
-    dateToYMD: (date: any) => string
-    collection: (params: { date?: Date; type: string; locale?: string }) => string | undefined
-    timeZones: () => string[]
-  }
-
-  disable: {
-    select: (el?: string) => void
-    spellCheck: (tmr?: number) => void
-    rightClick: (el?: string) => void
-    copy: (el?: string) => void
-    paste: (el?: string) => void
-    cut: (el?: string) => void
-    drag: (el?: string) => void
-  }
-
-  dispatch: {
-    set: (name: string, value?: any) => void
-    listen: (name: string, cb?: (e: Event) => void, flag?: boolean) => void
-    remove: (name: string) => void
-  }
-
-  element: {
-    fitScale: (el: any, scale?: number, fit?: boolean) => void
-    scaleBasedOnWindow: (elm: any, scale: number, fit: boolean) => void
-  }
-
-  events: {
-    list: (el: Element) => any
-    multi: (element: Element, eventNames: string, listener: EventListener) => void
-    copy: (el: string) => void
-    onDrag: (elem: string) => void
-    keys: (e: KeyboardEvent) => { key: string; ctrl: boolean; alt: boolean; shift: boolean }
-  }
-
-  form: {
-    serialize: (form: HTMLFormElement) => { [key: string]: any }
-    confirmType: (type: string, value: any) => boolean
-    required: (value: any) => string | undefined
-    minLength: (value: any, num?: number) => string | undefined
-    maxLength: (value: any, num?: number) => string | undefined
-    maxPhoneNumber: (value: any, num?: number) => string | undefined
-    isNumeric: (value: any) => boolean
-    isEmail: (value: any) => boolean
-    pattern: (e: Event) => void
-    noSpecialChars: (e: Event) => void
-    table: (size: [number, number], id: string, elem: HTMLElement) => void
-    sanitize: (str: string) => string | undefined
-  }
-
-  format: {
-    currency: (value: number, locale?: string, currency?: string) => string
-    phoneNumber: (value: string, countryCode?: string) => string
-  }
-
-  imports: {
-    file: (elem: string, file: string) => Promise<void>
-  }
-
-  json: {
-    counter: (json: any, key?: string, val?: any) => number | null
-    toCsv: (jsonInput: any) => string
-    saveCsvAs: (csvData: string, fileName: string) => void
-    is: (str: string) => boolean
-    parse: (file: string) => any
-    sanitize: (str: string) => string
-    sanitizeJsonValue: (str: string) => string
-  }
-
-  load: {
-    all: (context, cacheName?: string) => void
-    file: (filePath: string) => Promise<string>
-    fileToElement: (elementSelector: string, filePath: string) => Promise<void>
-    json: (filePath: string) => Promise<any>
-    remote: (path: string, method?: string, headers?: HeadersInit) => Promise<any>
-    script: (scripts: string[], elementSelector?: string) => void
-    toJson: (context, cacheName?: string) => void
-  }
-
-  logging: {
-    list: {
-      type: string
-      message: string
-    }
-    reg: (txt: string) => void
-    debug: (txt: string) => void
-    error: (txt: string) => void
-  }
-
-  math: {
-    rnd: () => number
-    tmr: () => number
-    add: (a: number, b: number) => number
-    sub: (a: number, b: number) => number
-    multi: (a: number, b: number) => number
-    div: (a: number, b: number) => number
-    rem: (a: number, b: number) => number
-    exp: (a: number, b: number) => number
-    isOdd: (a: number) => boolean
-    float2int: (a: number) => number
-    percent: (n: number, tot: number) => number
-    isPrime: (n: number) => boolean
-  }
-
-  memory: {
-    lock: (obj: string) => void
-    unlock: (obj: string) => void
-  }
-
-  object: {
-    toArray: (object: Record<string, any>) => [string, any][]
-    replaceNullObjects: (data: Record<string, any>) => Record<string, any>
-    serialize: (value: any) => any
-    deSerialize: (valueNew: any) => any
-    sort: (o: Record<string, any>) => Record<string, any>
-    toXML: (obj: Record<string, any>) => string
-    find: (array: any[], key: string, value: any) => any
-    instance: (obj: any) => any
-    updateByKey: (obj: Record<string, any>, key: string, newValue: any) => Record<string, any>
-    findindex: (array: any[], key: string) => number
-    parse: (val: any) => any
-    isObject: (val: any) => boolean
-    diff: (obj1: Record<string, any>, obj2: Record<string, any>) => Record<string, { obj1: any, obj2: any }>
-    path: (prop: string, array: string[], separator?: string) => string
-  }
-
-  path: {
-    rail: () => string[]
-    hash: () => string[]
-    query: (url: string) => Record<string, string>
-  }
-
-  promise: {
-    check: (p: any) => boolean
-    resolve: (data: any) => Promise<any>
-  }
-
-  sanitize: {
-    html: (s: string) => string
-  }
-
-  screen: {
-    fullScreen: (el: string) => void
-    toggle: (el: string) => void
-    info: () => {
-      width: number
-      height: number
-      availWidth: number
-      availHeight: number
-      colorDepth: number
-      pixelDepth: number
-    }
-  }
-
-  scrollbar: {
-    custom: (el: string, options: any) => void
-    indicator: (props: any) => void
-    position: {
-      get: (el: any) => void
-      set: (el: any) => void
-    }
-    smooth: (target: any, speed: any, smooth: any) => void
-    scrollTo: (container: string, element: string, gap?: number) => void
-  }
-
-  security: {
-    uuid: {
-      byVal: (string: string) => string
-      v4: string
-      v5: string
-    }
-    hashPass: (u: string, p: string, t?: string) => Promise<string>
-    crypt: (u: string, p: string, mode?: string) => string
-    deCrypt: (u: string, p: string, mode?: string) => string
-    AES_KeyGen: (passKey?: string) => string
-    SHA256_Hex: (passKey: string) => string
-  }
-
-  shortcut: {
-    keys: (e: any, trigger: any) => void
-  }
-
-  socket: {
-    info: () => string
-    start: (element: any, server: any, name: string) => void
-    conn: (id: any, server: any, name: string) => void
-    connect: (server: any, name: string) => void
-    open: (id: any, server: any, name: string) => void
-    send: (mex: any, type?: string) => void
-    ping: (name: string) => void
-    receive: (el?: any, name?: string) => void
-    keepAlive: (name: string) => void
-    check: () => void
-    list: () => WebSocket[]
-  }
-
-  svg: {
-    init: (container: HTMLElement, source1: [HTMLElement, string], source2: [HTMLElement, string], cb?: Function) => void
-    check: () => boolean
-    update: (rect1: HTMLElement, rect2: HTMLElement, cxn: HTMLElement) => void
-    getCurve: (p1: [number, number], p2: [number, number], dx: number) => string
-    getIntersection: (dx: number, dy: number, cx: number, cy: number, w: number, h: number) => [number, number]
-    setConnector: (source: HTMLElement, side: string) => HTMLElement
-    removeConnection: (container: HTMLElement) => void
-    makeScrollable: (svgContainer: HTMLElement, scrollContainer: HTMLElement, elm1: HTMLElement, elm2: HTMLElement, rect1: HTMLElement, rect2: HTMLElement) => void
-    makeDraggable: (evt: Event) => void
-    toggle: (evt: Event, container: HTMLElement, source1: HTMLElement, source2: HTMLElement) => void
-    convert: (options) => string | void
-  }
-
-  system: {
-    multiSplit: () => any
-  }
+  var dphelper: import("./dphelper")._dphelper
+}
 
-  text: {
-    trim(s: string, c: string, b: number, e: number): string
-    capitalize(txt: string): string
-    lower(txt: string): string
-    upper(txt: string): string
-    nl2br(str: string): string
-    sanitize(str: string): string
-    camelCase: {
-      toSpace(string: string): string
-      toUnderscore(string: string): string
-    }
-    fitContainer(el: string): void
-  }
+// --- AUTO-GENERATED TOOL TYPES START ---
+import { AiTool } from "../tools/ai/index"
+import { AnchorTool } from "../tools/anchor/index"
+import { ArrayTool } from "../tools/array/index"
+import { AudioTool } from "../tools/audio/index"
+import { AvoidTool } from "../tools/avoid/index"
+import { BrowserTool } from "../tools/browser/index"
+import { CheckTool } from "../tools/check/index"
+import { ColorTool } from "../tools/color/index"
+import { CookieTool } from "../tools/cookie/index"
+import { CoordsTool } from "../tools/coords/index"
+import { CreditsTool } from "../tools/credits/index"
+import { DateTool } from "../tools/date/index"
+import { DisableTool } from "../tools/disable/index"
+import { DispatchTool } from "../tools/dispatch/index"
+import { ElementsTool } from "../tools/elements/index"
+import { EventsTool } from "../tools/events/index"
+import { FetchTool } from "../tools/fetch/index"
+import { FormTool } from "../tools/form/index"
+import { FormatTool } from "../tools/format/index"
+import { JsonTool } from "../tools/json/index"
+import { LoadTool } from "../tools/load/index"
+import { LoggingTool } from "../tools/logging/index"
+import { MathTool } from "../tools/math/index"
+import { MemoryTool } from "../tools/memory/index"
+import { ObjectsTool } from "../tools/objects/index"
+import { PathTool } from "../tools/path/index"
+import { PromiseTool } from "../tools/promise/index"
+import { SanitizeTool } from "../tools/sanitize/index"
+import { ScreenTool } from "../tools/screen/index"
+import { ScrollbarTool } from "../tools/scrollbar/index"
+import { SecurityTool } from "../tools/security/index"
+import { ShortcutTool } from "../tools/shortcut/index"
+import { SocketTool } from "../tools/socket/index"
+import { SseTool } from "../tools/sse/index"
+import { SvgTool } from "../tools/svg/index"
+import { SyncTool } from "../tools/sync/index"
+import { SystemTool } from "../tools/system/index"
+import { TextTool } from "../tools/text/index"
+import { TimerTool } from "../tools/timer/index"
+import { ToolsTool } from "../tools/tools/index"
+import { TranslatorsTool } from "../tools/translators/index"
+import { TriggersTool } from "../tools/triggers/index"
+import { TypesTool } from "../tools/types/index"
+import { UiTool } from "../tools/ui/index"
+import { WindowTool } from "../tools/window/index"
+// --- AUTO-GENERATED TOOL TYPES END ---
+
+// --- GLOBALS ---
+
+type RTC_PEER_CONNECTION_LIKE = {
+  new(configuration?: RTCConfiguration): RTCPeerConnection
+}
 
-  timer: {
-    sleep(ms: number): Promise<void>
-    percentage(start: string, end: string): string
-  }
+declare const mozRTCPeerConnection: RTC_PEER_CONNECTION_LIKE
+declare const webkitRTCPeerConnection: RTC_PEER_CONNECTION_LIKE
 
-  tools: {
-    getip(): Promise<void>
-    byteSize(bytes: number): string
-    zIndex(): number
-    zeroToFalse(value: number): boolean | number
+declare const require: {
+  (id: string): unknown
+  context: (directory: string, useSubdirectories?: boolean, regExp?: RegExp) => {
+    (id: string): unknown
+    keys(): string[]
+    resolve(id: string): string
   }
+}
 
-  translators: {
-    convertMatrixToScale(values: any): number
-  }
+type RequireType = object
 
-  trigger: {
-    click(elem: string): void
-    change(elem: string): void
-    input(elem: string): void
-  }
+declare function confirm(message: string, func1: Function, func2?: Function): boolean
 
-  type: {
-    of(p: any): string
-    instOfObj(p: any): boolean
-    isNull(p: any): (i: any) => boolean
-    isBool(val: any): boolean
-  }
+// --- DPHELPER ---
 
-  ui: null
+export interface _dphelper {
+  [key: string]: any
 
-  window: {
-    enhancement(): void
-    animationframe(): any
-    center(params: { url: string; title: string; name: string; w: number; h: number }): void
-    onBeforeUnLoad(e: any): void
-    purge(d?: Document, time?: number): void
-    stopZoomWheel(e: any): void
-    setZoom(element?: string, zoom?: number): string
-    getZoom(element?: string): number
+  // --- AUTO-GENERATED TOOL MEMBERS START ---
+  ai: AiTool
+  anchor: AnchorTool
+  array: ArrayTool
+  audio: AudioTool
+  avoid: AvoidTool
+  browser: BrowserTool
+  check: CheckTool
+  color: ColorTool
+  cookie: CookieTool
+  coords: CoordsTool
+  credits: CreditsTool
+  date: DateTool
+  disable: DisableTool
+  dispatch: DispatchTool
+  element: ElementsTool
+  events: EventsTool
+  fetch: FetchTool
+  form: FormTool
+  format: FormatTool
+  json: JsonTool
+  load: LoadTool
+  logging: LoggingTool
+  math: MathTool
+  memory: MemoryTool
+  object: ObjectsTool
+  path: PathTool
+  promise: PromiseTool
+  sanitize: SanitizeTool
+  screen: ScreenTool
+  scrollbar: ScrollbarTool
+  security: SecurityTool
+  shortcut: ShortcutTool
+  socket: SocketTool
+  sse: SseTool
+  svg: SvgTool
+  sync: SyncTool
+  system: SystemTool
+  text: TextTool
+  timer: TimerTool
+  tools: ToolsTool
+  translators: TranslatorsTool
+  trigger: TriggersTool
+  type: TypesTool
+  ui: UiTool
+  window: WindowTool
+// --- AUTO-GENERATED TOOL MEMBERS END ---
+
+  setDescription: (description: Description, newObj: any) => void
+  setProps: (root: any, desc: any, options?: any) => void
+  _list: {
+    scripts: Description[]
+    sockets: any[]
+    [key: string]: any
   }
-
 }
 
-////////////////////////////////////////////////////////////////////////////
-
 declare var dphelper: _dphelper
 type dphelper = _dphelper
 
-declare var arguments: any
-type arguments = any
-
-///////////////////
-
-interface SubCommand {
-  name: string
-  version: string
-  example: string
-  author: string
-  creationDate: string
-  lastMod: string
-  type: string
-  active: boolean
-  description: string
-  subCommand: Array<SubCommand> | typeof Array
-}
-
-interface Description {
-  name: string,
-  active: boolean,
-  subCommand: Array<SubCommand>,
-}
-
-declare function confirm(message: string, func1: Function, func2?: Function): boolean
+export { dphelper, _dphelper }