promidas 2.0.0

package/dist/utils/index.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Utility Functions and Data Converters.
+ *
+ * This module provides a comprehensive set of utility functions for working with
+ * ProtoPedia data, including type-safe converters, time parsing, configuration
+ * merging, and secure logging utilities.
+ *
+ * ## Data Converters
+ *
+ * Transform ProtoPedia API numeric codes into human-readable labels:
+ *
+ * - {@link getPrototypeStatusLabel} — Convert status code to label (e.g., `1` → `'公開'`)
+ * - {@link getPrototypeReleaseFlagLabel} — Convert release flag to label (e.g., `1` → `'フリー'`)
+ * - {@link getPrototypeThanksFlagLabel} — Convert thanks flag to label (e.g., `1` → `'受付中'`)
+ * - {@link getPrototypeLicenseTypeLabel} — Convert license type to label (e.g., `1` → `'CC BY'`)
+ *
+ * ## Time Utilities
+ *
+ * Parse and normalize ProtoPedia timestamps:
+ *
+ * - {@link parseProtoPediaTimestamp} — Parse JST timestamps to UTC ISO-8601
+ * - {@link parseW3cDtfTimestamp} — Parse W3C-DTF timestamps to UTC ISO-8601
+ * - {@link JST_OFFSET_MS} — JST timezone offset constant (9 hours in milliseconds)
+ *
+ * ## Configuration Utilities
+ *
+ * Deep merge configuration objects safely:
+ *
+ * - {@link deepMerge} — Deep merge with circular reference protection and prototype pollution prevention
+ * - {@link isPlainObject} — Type guard for plain JavaScript objects
+ *
+ * ## Logging Utilities
+ *
+ * Sanitize data for secure logging:
+ *
+ * - {@link sanitizeDataForLogging} — Redact sensitive data and handle circular references
+ *
+ * ## Dependencies
+ *
+ * This module intentionally depends on `lib/types` for data structures. This is
+ * a correct architectural dependency, as utilities often operate on defined data
+ * types. This design ensures type-safe utility operations.
+ *
+ * ## Standalone Usage
+ *
+ * All utilities can be used independently without the full repository layer:
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   getPrototypeStatusLabel,
+ *   parseProtoPediaTimestamp,
+ *   deepMerge,
+ *   sanitizeDataForLogging,
+ * } from 'promidas/utils';
+ *
+ * // Convert status code
+ * const label = getPrototypeStatusLabel(1); // => '公開'
+ *
+ * // Parse timestamp
+ * const isoDate = parseProtoPediaTimestamp('2025-11-14 12:03:07.0');
+ * // => '2025-11-14T03:03:07.000Z'
+ *
+ * // Merge configurations
+ * const config = deepMerge(defaults, overrides);
+ *
+ * // Sanitize for logging
+ * const safe = sanitizeDataForLogging({ token: 'secret', data: 'visible' });
+ * // => { token: '[REDACTED]', data: 'visible' }
+ * ```
+ *
+ * @module
+ * @see https://protopedia.gitbook.io/helpcenter/info/2022.05.23 for ProtoPedia field specifications
+ */
+export { getPrototypeStatusLabel, getPrototypeReleaseFlagLabel, getPrototypeThanksFlagLabel, getPrototypeLicenseTypeLabel, } from './converters/index.js';
+export { JST_OFFSET_MS, parseProtoPediaTimestamp, parseW3cDtfTimestamp, } from './time/index.js';
+export { deepMerge, isPlainObject } from './deep-merge.js';
+export { sanitizeDataForLogging } from './logger-utils.js';
+export { validateNormalizedPrototype, validateNormalizedPrototypeArray, type ValidationErrorCode, type ValidationResult, type ValidationSuccess, type ValidationFailure, } from './validation/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/utils/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AAGH,OAAO,EACL,uBAAuB,EACvB,4BAA4B,EAC5B,2BAA2B,EAC3B,4BAA4B,GAC7B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,aAAa,EACb,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAG3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAG3D,OAAO,EACL,2BAA2B,EAC3B,gCAAgC,EAChC,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,GACvB,MAAM,uBAAuB,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,85 @@
+/**
+ * Utility Functions and Data Converters.
+ *
+ * This module provides a comprehensive set of utility functions for working with
+ * ProtoPedia data, including type-safe converters, time parsing, configuration
+ * merging, and secure logging utilities.
+ *
+ * ## Data Converters
+ *
+ * Transform ProtoPedia API numeric codes into human-readable labels:
+ *
+ * - {@link getPrototypeStatusLabel} — Convert status code to label (e.g., `1` → `'公開'`)
+ * - {@link getPrototypeReleaseFlagLabel} — Convert release flag to label (e.g., `1` → `'フリー'`)
+ * - {@link getPrototypeThanksFlagLabel} — Convert thanks flag to label (e.g., `1` → `'受付中'`)
+ * - {@link getPrototypeLicenseTypeLabel} — Convert license type to label (e.g., `1` → `'CC BY'`)
+ *
+ * ## Time Utilities
+ *
+ * Parse and normalize ProtoPedia timestamps:
+ *
+ * - {@link parseProtoPediaTimestamp} — Parse JST timestamps to UTC ISO-8601
+ * - {@link parseW3cDtfTimestamp} — Parse W3C-DTF timestamps to UTC ISO-8601
+ * - {@link JST_OFFSET_MS} — JST timezone offset constant (9 hours in milliseconds)
+ *
+ * ## Configuration Utilities
+ *
+ * Deep merge configuration objects safely:
+ *
+ * - {@link deepMerge} — Deep merge with circular reference protection and prototype pollution prevention
+ * - {@link isPlainObject} — Type guard for plain JavaScript objects
+ *
+ * ## Logging Utilities
+ *
+ * Sanitize data for secure logging:
+ *
+ * - {@link sanitizeDataForLogging} — Redact sensitive data and handle circular references
+ *
+ * ## Dependencies
+ *
+ * This module intentionally depends on `lib/types` for data structures. This is
+ * a correct architectural dependency, as utilities often operate on defined data
+ * types. This design ensures type-safe utility operations.
+ *
+ * ## Standalone Usage
+ *
+ * All utilities can be used independently without the full repository layer:
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   getPrototypeStatusLabel,
+ *   parseProtoPediaTimestamp,
+ *   deepMerge,
+ *   sanitizeDataForLogging,
+ * } from 'promidas/utils';
+ *
+ * // Convert status code
+ * const label = getPrototypeStatusLabel(1); // => '公開'
+ *
+ * // Parse timestamp
+ * const isoDate = parseProtoPediaTimestamp('2025-11-14 12:03:07.0');
+ * // => '2025-11-14T03:03:07.000Z'
+ *
+ * // Merge configurations
+ * const config = deepMerge(defaults, overrides);
+ *
+ * // Sanitize for logging
+ * const safe = sanitizeDataForLogging({ token: 'secret', data: 'visible' });
+ * // => { token: '[REDACTED]', data: 'visible' }
+ * ```
+ *
+ * @module
+ * @see https://protopedia.gitbook.io/helpcenter/info/2022.05.23 for ProtoPedia field specifications
+ */
+// Data Converters
+export { getPrototypeStatusLabel, getPrototypeReleaseFlagLabel, getPrototypeThanksFlagLabel, getPrototypeLicenseTypeLabel, } from './converters/index.js';
+// Time Utilities
+export { JST_OFFSET_MS, parseProtoPediaTimestamp, parseW3cDtfTimestamp, } from './time/index.js';
+// Configuration Utilities
+export { deepMerge, isPlainObject } from './deep-merge.js';
+// Logging Utilities
+export { sanitizeDataForLogging } from './logger-utils.js';
+// Validation Utilities
+export { validateNormalizedPrototype, validateNormalizedPrototypeArray, } from './validation/index.js';
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/utils/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AAEH,kBAAkB;AAClB,OAAO,EACL,uBAAuB,EACvB,4BAA4B,EAC5B,2BAA2B,EAC3B,4BAA4B,GAC7B,MAAM,uBAAuB,CAAC;AAE/B,iBAAiB;AACjB,OAAO,EACL,aAAa,EACb,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,iBAAiB,CAAC;AAEzB,0BAA0B;AAC1B,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAE3D,oBAAoB;AACpB,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,uBAAuB;AACvB,OAAO,EACL,2BAA2B,EAC3B,gCAAgC,GAKjC,MAAM,uBAAuB,CAAC"}

package/dist/utils/logger-utils.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Utility functions for secure logging operations.
+ *
+ * This module provides utilities for sanitizing data before logging to prevent
+ * sensitive information leakage. It handles circular references, prototype pollution,
+ * and provides protection against DoS attacks through depth limiting.
+ *
+ * @module
+ */
+/**
+ * Options for customizing data sanitization behavior.
+ */
+export interface SanitizeOptions {
+    /**
+     * Additional key patterns to treat as sensitive and redact.
+     * These are added to the default list of sensitive keys.
+     */
+    additionalSensitiveKeys?: string[];
+}
+/**
+ * Sanitizes data for secure logging by redacting sensitive information.
+ *
+ * This function deeply traverses objects, arrays, and errors to redact sensitive
+ * fields while preserving structure for debugging. It provides multiple layers of
+ * protection against common security and reliability issues:
+ *
+ * **Security Features:**
+ * - Redacts sensitive keys (token, password, secret, auth, credential)
+ * - Prevents prototype pollution by skipping dangerous keys
+ * - Uses case-insensitive pattern matching for sensitive data detection
+ *
+ * **Reliability Features:**
+ * - Handles circular references using WeakSet tracking
+ * - Limits recursion depth to prevent stack overflow (max 100 levels)
+ * - Preserves non-serializable types (functions, symbols, bigints)
+ *
+ * **Type Support:**
+ * - Primitives: returned as-is (strings, numbers, booleans, null, undefined)
+ * - Functions: converted to `[Function: name]` strings
+ * - Symbols: converted to string representation
+ * - BigInts: converted to string with 'n' suffix
+ * - Errors: extracts name, message, stack, and other properties
+ * - Arrays: recursively sanitized element by element
+ * - Maps: converted to object with `__type` and `entries`; if key is sensitive, both key and value are redacted
+ * - Sets: converted to object with `__type` and `values`
+ * - Objects: recursively sanitized key by key with sensitive data redacted
+ *
+ * @param data - The data to sanitize (any type)
+ * @param options - Optional configuration for sanitization
+ * @returns A new sanitized version with sensitive information redacted
+ *
+ * @example
+ * Basic usage with sensitive data:
+ * ```typescript
+ * const data = {
+ *   username: 'john',
+ *   apiToken: 'secret-key-123',
+ *   settings: { theme: 'dark' }
+ * };
+ *
+ * const sanitized = sanitizeDataForLogging(data);
+ * // Result: { username: 'john', apiToken: '***', settings: { theme: 'dark' } }
+ * ```
+ *
+ * @example
+ * Usage with custom sensitive keys:
+ * ```typescript
+ * const data = {
+ *   apiKey: 'secret',
+ *   ssn: '123-45-6789'
+ * };
+ *
+ * const sanitized = sanitizeDataForLogging(data, {
+ *   additionalSensitiveKeys: ['ssn']
+ * });
+ * // Result: { apiKey: '***', ssn: '***' } // 'apiKey' contains 'key' which might not match default, but 'ssn' will match.
+ * ```
+ *
+ * @example
+ * Handling circular references:
+ * ```typescript
+ * const obj: any = { name: 'test' };
+ * obj.self = obj;
+ *
+ * const sanitized = sanitizeDataForLogging(obj);
+ * // Result: { name: 'test', self: '[Circular]' }
+ * ```
+ *
+ * @example
+ * Error object sanitization:
+ * ```typescript
+ * const error = new Error('Failed to authenticate');
+ * error.apiToken = 'secret';
+ *
+ * const sanitized = sanitizeDataForLogging(error);
+ * // Result: { name: 'Error', message: 'Failed...', stack: '...', apiToken: '***' }
+ * ```
+ */
+export declare function sanitizeDataForLogging(data: unknown, options?: SanitizeOptions): unknown;
+//# sourceMappingURL=logger-utils.d.ts.map

package/dist/utils/logger-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-utils.d.ts","sourceRoot":"","sources":["../../lib/utils/logger-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA6BH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;CACpC;AAsED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAmHT"}

package/dist/utils/logger-utils.js

@@ -0,0 +1,265 @@
+/**
+ * Utility functions for secure logging operations.
+ *
+ * This module provides utilities for sanitizing data before logging to prevent
+ * sensitive information leakage. It handles circular references, prototype pollution,
+ * and provides protection against DoS attacks through depth limiting.
+ *
+ * @module
+ */
+/**
+ * List of sensitive key patterns to redact in logged data.
+ * These patterns are matched case-insensitively.
+ */
+const SENSITIVE_KEYS = ['token', 'auth', 'password', 'secret', 'credential'];
+/**
+ * Pre-compiled regular expression for efficient sensitive key detection.
+ * Matches any key containing tokens like 'token', 'auth', 'password', etc.
+ */
+const SENSITIVE_KEY_PATTERN = new RegExp(SENSITIVE_KEYS.join('|'), 'i');
+/**
+ * Keys that are dangerous for prototype pollution attacks.
+ * These keys are always skipped during sanitization to prevent security vulnerabilities.
+ */
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+/**
+ * Maximum recursion depth to prevent stack overflow from deeply nested objects.
+ * This protects against DoS attacks using maliciously crafted data structures.
+ */
+const MAX_DEPTH = 100;
+/**
+ * Cache for compiled RegExp patterns to avoid recompilation on every call.
+ * Key is the sorted, joined list of sensitive keys.
+ */
+const regexCache = new Map();
+/**
+ * Maximum allowed length for individual custom sensitive key pattern.
+ * This prevents ReDoS attacks from excessively long or complex patterns.
+ */
+const MAX_PATTERN_LENGTH = 100;
+/**
+ * Validates custom sensitive keys to prevent ReDoS attacks.
+ * @param keys - Array of custom sensitive key patterns
+ * @throws {TypeError} If any key is invalid
+ */
+function validateSensitiveKeys(keys) {
+    for (const key of keys) {
+        if (typeof key !== 'string') {
+            throw new TypeError(`Invalid sensitive key: expected string, got ${typeof key}`);
+        }
+        if (key.length === 0) {
+            throw new TypeError('Sensitive key cannot be empty');
+        }
+        if (key.length > MAX_PATTERN_LENGTH) {
+            throw new TypeError(`Sensitive key too long (max ${MAX_PATTERN_LENGTH} characters): ${key.slice(0, 20)}...`);
+        }
+        // Check for potentially dangerous regex patterns
+        if (/[*+{].*[*+{]/.test(key)) {
+            throw new TypeError(`Potentially dangerous regex pattern detected: ${key}`);
+        }
+    }
+}
+/**
+ * Gets or creates a cached RegExp for the given sensitive keys.
+ * @param additionalKeys - Additional keys to include in the pattern
+ * @returns Compiled RegExp for matching sensitive keys
+ */
+function getSensitivePattern(additionalKeys = []) {
+    if (additionalKeys.length === 0) {
+        return SENSITIVE_KEY_PATTERN;
+    }
+    // Validate custom keys before using them
+    validateSensitiveKeys(additionalKeys);
+    // Create cache key from sorted list of all keys
+    const allKeys = [...SENSITIVE_KEYS, ...additionalKeys].sort();
+    const cacheKey = allKeys.join('|');
+    // Return cached pattern if available
+    let pattern = regexCache.get(cacheKey);
+    if (!pattern) {
+        pattern = new RegExp(cacheKey, 'i');
+        regexCache.set(cacheKey, pattern);
+    }
+    return pattern;
+}
+/**
+ * Sanitizes data for secure logging by redacting sensitive information.
+ *
+ * This function deeply traverses objects, arrays, and errors to redact sensitive
+ * fields while preserving structure for debugging. It provides multiple layers of
+ * protection against common security and reliability issues:
+ *
+ * **Security Features:**
+ * - Redacts sensitive keys (token, password, secret, auth, credential)
+ * - Prevents prototype pollution by skipping dangerous keys
+ * - Uses case-insensitive pattern matching for sensitive data detection
+ *
+ * **Reliability Features:**
+ * - Handles circular references using WeakSet tracking
+ * - Limits recursion depth to prevent stack overflow (max 100 levels)
+ * - Preserves non-serializable types (functions, symbols, bigints)
+ *
+ * **Type Support:**
+ * - Primitives: returned as-is (strings, numbers, booleans, null, undefined)
+ * - Functions: converted to `[Function: name]` strings
+ * - Symbols: converted to string representation
+ * - BigInts: converted to string with 'n' suffix
+ * - Errors: extracts name, message, stack, and other properties
+ * - Arrays: recursively sanitized element by element
+ * - Maps: converted to object with `__type` and `entries`; if key is sensitive, both key and value are redacted
+ * - Sets: converted to object with `__type` and `values`
+ * - Objects: recursively sanitized key by key with sensitive data redacted
+ *
+ * @param data - The data to sanitize (any type)
+ * @param options - Optional configuration for sanitization
+ * @returns A new sanitized version with sensitive information redacted
+ *
+ * @example
+ * Basic usage with sensitive data:
+ * ```typescript
+ * const data = {
+ *   username: 'john',
+ *   apiToken: 'secret-key-123',
+ *   settings: { theme: 'dark' }
+ * };
+ *
+ * const sanitized = sanitizeDataForLogging(data);
+ * // Result: { username: 'john', apiToken: '***', settings: { theme: 'dark' } }
+ * ```
+ *
+ * @example
+ * Usage with custom sensitive keys:
+ * ```typescript
+ * const data = {
+ *   apiKey: 'secret',
+ *   ssn: '123-45-6789'
+ * };
+ *
+ * const sanitized = sanitizeDataForLogging(data, {
+ *   additionalSensitiveKeys: ['ssn']
+ * });
+ * // Result: { apiKey: '***', ssn: '***' } // 'apiKey' contains 'key' which might not match default, but 'ssn' will match.
+ * ```
+ *
+ * @example
+ * Handling circular references:
+ * ```typescript
+ * const obj: any = { name: 'test' };
+ * obj.self = obj;
+ *
+ * const sanitized = sanitizeDataForLogging(obj);
+ * // Result: { name: 'test', self: '[Circular]' }
+ * ```
+ *
+ * @example
+ * Error object sanitization:
+ * ```typescript
+ * const error = new Error('Failed to authenticate');
+ * error.apiToken = 'secret';
+ *
+ * const sanitized = sanitizeDataForLogging(error);
+ * // Result: { name: 'Error', message: 'Failed...', stack: '...', apiToken: '***' }
+ * ```
+ */
+export function sanitizeDataForLogging(data, options = {}) {
+    const seen = new WeakSet();
+    // Get cached regex pattern for sensitive key detection
+    const sensitivePattern = getSensitivePattern(options.additionalSensitiveKeys);
+    function isSensitive(key) {
+        return sensitivePattern.test(key);
+    }
+    // Pre-define Error property exclusion Set for performance
+    const ERROR_BASE_PROPS = new Set(['name', 'message', 'stack']);
+    function sanitize(value, depth = 0) {
+        // Depth limit check
+        if (depth >= MAX_DEPTH) {
+            return '[Max Depth Exceeded]';
+        }
+        // Primitives and null
+        if (value === null || typeof value !== 'object') {
+            if (typeof value === 'function') {
+                return `[Function: ${value.name || 'anonymous'}]`;
+            }
+            if (typeof value === 'symbol') {
+                return value.toString();
+            }
+            if (typeof value === 'bigint') {
+                return `${value.toString()}n`;
+            }
+            return value;
+        }
+        // Circular reference check
+        if (seen.has(value)) {
+            return '[Circular]';
+        }
+        seen.add(value);
+        // Handle Error objects
+        if (value instanceof Error) {
+            const errorObj = {
+                name: value.name,
+                message: value.message,
+                stack: value.stack,
+            };
+            // Copy other properties (using getOwnPropertyNames to include non-enumerable properties)
+            for (const key of Object.getOwnPropertyNames(value)) {
+                if (!ERROR_BASE_PROPS.has(key)) {
+                    if (isSensitive(key)) {
+                        errorObj[key] = '***';
+                    }
+                    else {
+                        const errorValue = value;
+                        errorObj[key] = sanitize(errorValue[key], depth + 1);
+                    }
+                }
+            }
+            return errorObj;
+        }
+        // Handle Map (preserve type information and check keys for sensitive data)
+        if (value instanceof Map) {
+            return {
+                __type: 'Map',
+                entries: Array.from(value.entries()).map(([k, v]) => {
+                    // Check if key itself is sensitive (when it's a string)
+                    const isKeySensitive = typeof k === 'string' && isSensitive(k);
+                    const sanitizedKey = isKeySensitive ? '***' : sanitize(k, depth + 1);
+                    // If key is sensitive, redact the value as well to prevent leakage
+                    const sanitizedValue = isKeySensitive
+                        ? '***'
+                        : sanitize(v, depth + 1);
+                    return [sanitizedKey, sanitizedValue];
+                }),
+            };
+        }
+        // Handle Set (preserve type information)
+        if (value instanceof Set) {
+            return {
+                __type: 'Set',
+                values: Array.from(value).map((v) => sanitize(v, depth + 1)),
+            };
+        }
+        // Handle Arrays
+        if (Array.isArray(value)) {
+            return value.map((item) => sanitize(item, depth + 1));
+        }
+        // Handle Plain Objects
+        const sanitizedObj = {};
+        const obj = value;
+        // Iterate over own enumerable properties
+        for (const key of Object.keys(obj)) {
+            // Skip dangerous prototype pollution keys
+            if (DANGEROUS_KEYS.has(key)) {
+                continue;
+            }
+            // Redact sensitive keys
+            if (isSensitive(key)) {
+                sanitizedObj[key] = '***';
+            }
+            else {
+                // Recursively sanitize
+                sanitizedObj[key] = sanitize(obj[key], depth + 1);
+            }
+        }
+        return sanitizedObj;
+    }
+    return sanitize(data);
+}
+//# sourceMappingURL=logger-utils.js.map

package/dist/utils/logger-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-utils.js","sourceRoot":"","sources":["../../lib/utils/logger-utils.ts"],"names":[],"mappings":"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"}

package/dist/utils/time/constants.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Time-related constants for ProtoPedia timestamp handling.
+ *
+ * @module utils/time/constants
+ */
+/**
+ * JST (Japan Standard Time) offset in milliseconds.
+ *
+ * JST is UTC+9, which corresponds to 9 hours * 60 minutes * 60 seconds * 1000 ms.
+ * This constant is used to convert JST timestamps (without explicit offset)
+ * to UTC.
+ */
+export declare const JST_OFFSET_MS: number;
+//# sourceMappingURL=constants.d.ts.map

package/dist/utils/time/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../lib/utils/time/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,QAAqB,CAAC"}

package/dist/utils/time/constants.js

@@ -0,0 +1,14 @@
+/**
+ * Time-related constants for ProtoPedia timestamp handling.
+ *
+ * @module utils/time/constants
+ */
+/**
+ * JST (Japan Standard Time) offset in milliseconds.
+ *
+ * JST is UTC+9, which corresponds to 9 hours * 60 minutes * 60 seconds * 1000 ms.
+ * This constant is used to convert JST timestamps (without explicit offset)
+ * to UTC.
+ */
+export const JST_OFFSET_MS = 9 * 60 * 60 * 1000;
+//# sourceMappingURL=constants.js.map

package/dist/utils/time/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../lib/utils/time/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/dist/utils/time/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Time utilities for ProtoPedia timestamp handling.
+ *
+ * Provides parsers and normalizers for ProtoPedia-specific JST timestamps
+ * and W3C-DTF (W3C Date and Time Formats) compliant timestamps.
+ *
+ * @module utils/time
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   parseProtoPediaTimestamp,
+ *   parseW3cDtfTimestamp,
+ *   JST_OFFSET_MS,
+ * } from 'promidas/utils/time';
+ *
+ * // Parse ProtoPedia format (JST)
+ * parseProtoPediaTimestamp('2025-11-14 12:03:07.0');
+ * // => '2025-11-14T03:03:07.000Z'
+ *
+ * // Parse W3C-DTF format
+ * parseW3cDtfTimestamp('2025-11-14T12:03:07+09:00');
+ * // => '2025-11-14T03:03:07.000Z'
+ * ```
+ */
+export { JST_OFFSET_MS } from './constants.js';
+export { parseProtoPediaTimestamp, parseW3cDtfTimestamp } from './parser.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/time/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/utils/time/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC"}

package/dist/utils/time/index.js

@@ -0,0 +1,28 @@
+/**
+ * Time utilities for ProtoPedia timestamp handling.
+ *
+ * Provides parsers and normalizers for ProtoPedia-specific JST timestamps
+ * and W3C-DTF (W3C Date and Time Formats) compliant timestamps.
+ *
+ * @module utils/time
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   parseProtoPediaTimestamp,
+ *   parseW3cDtfTimestamp,
+ *   JST_OFFSET_MS,
+ * } from 'promidas/utils/time';
+ *
+ * // Parse ProtoPedia format (JST)
+ * parseProtoPediaTimestamp('2025-11-14 12:03:07.0');
+ * // => '2025-11-14T03:03:07.000Z'
+ *
+ * // Parse W3C-DTF format
+ * parseW3cDtfTimestamp('2025-11-14T12:03:07+09:00');
+ * // => '2025-11-14T03:03:07.000Z'
+ * ```
+ */
+export { JST_OFFSET_MS } from './constants.js';
+export { parseProtoPediaTimestamp, parseW3cDtfTimestamp } from './parser.js';
+//# sourceMappingURL=index.js.map

package/dist/utils/time/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../lib/utils/time/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC"}