tessl/npm-utility

A collection of useful TypeScript/JavaScript utilities for crypto, date, string, number, JSON operations and more.

—

Pending

Overview

Eval results

Files

Date Formatting and Processing

Name: tessl/npm-utility
Author: tessl

Comprehensive date formatting utilities with multiple output formats, timezone support, caching for performance, and timestamp conversion operations optimized for logging and data processing.

Capabilities

Log Date Formatting

Primary date formatting function for logging with millisecond precision and customizable separators.

/**
 * Normal log format date with milliseconds
 * @param d - Date object, string separator, or null (defaults to current date)
 * @param msSep - Millisecond separator (defaults to '.')
 * @returns Formatted date string: "YYYY-MM-DD HH:mm:ss.SSS"
 */
function logDate(d?: Date | string | null, msSep?: string): string;

// Alias for logDate
const YYYYMMDDHHmmssSSS = logDate;

Usage Examples:

import { logDate, YYYYMMDDHHmmssSSS } from "utility";

// Current timestamp with default formatting
const now = logDate();
// Result: "2025-09-06 12:05:30.123"

// Custom date with default formatting
const custom = logDate(new Date('2025-01-01T10:30:45.678Z'));
// Result: "2025-01-01 10:30:45.678"

// Custom millisecond separator
const customSep = logDate(new Date(), ',');
// Result: "2025-09-06 12:05:30,123"

// Using string parameter as separator
const strSep = logDate(':');
// Result: "2025-09-06 12:05:30:123"

// Using alias
const aliased = YYYYMMDDHHmmssSSS();

Standard Date-Time Formatting

Date-time formatting without milliseconds with customizable separators.

/**
 * YYYY-MM-DD HH:mm:ss format date string
 * @param d - Date, string, or number (defaults to current date)
 * @param options - Formatting options for separators
 * @returns Formatted date string
 */
function YYYYMMDDHHmmss(d?: Date | string | number, options?: YYYYMMDDHHmmssOptions): string;

interface YYYYMMDDHHmmssOptions {
  dateSep?: string;
  timeSep?: string;
}

Usage Examples:

import { YYYYMMDDHHmmss } from "utility";

// Default formatting
const standard = YYYYMMDDHHmmss();
// Result: "2025-09-06 12:05:30"

// Custom separators
const custom = YYYYMMDDHHmmss(new Date(), { dateSep: '/', timeSep: '.' });
// Result: "2025/09/06 12.05.30"

// From timestamp
const fromTs = YYYYMMDDHHmmss(1641024000000);
// Result: "2022-01-01 10:00:00"

// From ISO string
const fromIso = YYYYMMDDHHmmss('2025-12-25T15:30:45Z');

Date-Only Formatting

Date-only formatting with customizable separators.

/**
 * YYYY-MM-DD format date string
 * @param d - Date, string, or separator (defaults to current date)
 * @param sep - Date separator (defaults to '-')
 * @returns Formatted date string
 */
function YYYYMMDD(d?: Date | string, sep?: string): string;

Usage Examples:

import { YYYYMMDD } from "utility";

// Default formatting
const today = YYYYMMDD();
// Result: "2025-09-06"

// Custom separator
const slashDate = YYYYMMDD(new Date(), '/');
// Result: "2025/09/06"

// String parameter as separator
const dotDate = YYYYMMDD('.');
// Result: "2025.09.06"

// Specific date
const specific = YYYYMMDD(new Date('2025-12-25'));
// Result: "2025-12-25"

Access Log Formatting

Apache/Nginx compatible access log date formatting with timezone information.

/**
 * Access log format date with timezone
 * @param d - Date object (defaults to current date)
 * @returns Formatted date string: "DD/MMM/YYYY:HH:mm:ss +ZZZZ"
 */
function accessLogDate(d?: Date): string;

Usage Examples:

import { accessLogDate } from "utility";

// Current date in access log format
const logEntry = accessLogDate();
// Result: "06/Sep/2025:12:05:30 +0000"

// Specific date
const customLog = accessLogDate(new Date('2025-04-16T16:40:09Z'));
// Result: "16/Apr/2025:16:40:09 +0000"

Timezone Operations

Timezone calculation and caching utilities.

/**
 * Get timezone string with caching for performance
 * @param d - Date object
 * @returns Timezone string (e.g., "+0800", "-0500")
 */
function getTimezone(d: Date): string;

/**
 * Calculate timezone offset for a date
 * @param date - Date object
 * @returns Timezone string
 */
function resetTimezone(date: Date): string;

Date Structure Operations

Date structure utilities for numeric date representations.

/**
 * Return datetime structure object
 * @param now - Date object (defaults to current date)
 * @returns Date structure with numeric representations
 */
function datestruct(now?: Date): DateStruct;

interface DateStruct {
  YYYYMMDD: number;  // e.g., 20250906
  H: number;         // Hour (0-23)
}

Usage Examples:

import { datestruct } from "utility";

// Current date structure
const current = datestruct();
// Result: { YYYYMMDD: 20250906, H: 12 }

// Specific date structure
const specific = datestruct(new Date('2025-12-25T15:30:00'));
// Result: { YYYYMMDD: 20251225, H: 15 }

Timestamp Operations

Unix timestamp conversion and parsing utilities.

/**
 * Get Unix timestamp in seconds or convert timestamp to Date
 * @param t - Optional timestamp to convert (10 or 13 digits)
 * @returns Current timestamp in seconds, or Date object if input provided
 */
function timestamp(t?: number | string): number | Date;

/**
 * Parse timestamp to Date object
 * @param t - Timestamp in seconds or milliseconds
 * @returns Date object
 */
function parseTimestamp(t: number | string): Date;

/**
 * Convert Date object to Unix timestamp in seconds
 * @param date - Date object to convert
 * @returns Unix timestamp in seconds
 */
function dateToUnixTimestamp(date: Date): number;

Usage Examples:

import { timestamp, parseTimestamp, dateToUnixTimestamp } from "utility";

// Get current timestamp
const now = timestamp();
// Result: 1693934730 (seconds since epoch)

// Convert 10-digit timestamp to Date
const date10 = timestamp(1693934730);
// Result: Date object

// Convert 13-digit timestamp to Date
const date13 = timestamp(1693934730123);
// Result: Date object

// Parse timestamp string
const parsed = parseTimestamp('1693934730');
// Result: Date object

// Convert Date to timestamp
const ts = dateToUnixTimestamp(new Date());
// Result: Unix timestamp in seconds

Millisecond Formatting

Format dates from millisecond values with various output formats.

/**
 * Provide milliseconds, return a formatted string
 * @param milliseconds - Milliseconds since epoch
 * @param format - Output format enum
 * @returns Formatted date string
 */
function getDateFromMilliseconds(milliseconds: number, format?: DateFormat): string;

enum DateFormat {
  DateTimeWithTimeZone = 'DateTimeWithTimeZone',
  DateTimeWithMilliSeconds = 'DateTimeWithMilliSeconds', 
  DateTimeWithSeconds = 'DateTimeWithSeconds',
  UnixTimestamp = 'UnixTimestamp',
}

Usage Examples:

import { getDateFromMilliseconds, DateFormat } from "utility";

const ms = 1693934730123;

// Default format (YYYY-MM-DD)
const default = getDateFromMilliseconds(ms);
// Result: "2023-09-05"

// With timezone
const tz = getDateFromMilliseconds(ms, DateFormat.DateTimeWithTimeZone);
// Result: "05/Sep/2023:15:52:10 +0000"

// With milliseconds
const withMs = getDateFromMilliseconds(ms, DateFormat.DateTimeWithMilliSeconds);
// Result: "2023-09-05 15:52:10.123"

// Unix timestamp
const unix = getDateFromMilliseconds(ms, DateFormat.UnixTimestamp);
// Result: "1693934730"

Date String Parts

Utility for getting date components as string arrays.

/**
 * Return date string parts as array
 * @param d - Date object (defaults to current date)
 * @param onlyDate - Return only date parts (no time)
 * @returns Array of date/time parts as strings
 */
function getDateStringParts(d?: Date, onlyDate?: boolean): string[];

Usage Examples:

import { getDateStringParts } from "utility";

// Full date-time parts
const fullParts = getDateStringParts(new Date('2025-09-06T12:05:30.123Z'));
// Result: ["2025", "09", "06", "12", "05", "30"]

// Date parts only
const dateParts = getDateStringParts(new Date(), true);
// Result: ["2025", "09", "06"]

Install with Tessl CLI