promidas 2.0.0

package/dist/fetcher/utils/index.js

@@ -0,0 +1,12 @@
+/**
+ * @module protopedia/utils
+ *
+ * Utility functions for ProtoPedia API data processing.
+ */
+export { splitPipeSeparatedString } from './string-parsers.js';
+export { normalizePrototype } from './normalize-prototype.js';
+export { normalizeProtoPediaTimestamp } from './normalize-protopedia-timestamp.js';
+export { handleApiError } from './errors/handler.js';
+export { PromidasTimeoutError } from '../errors/fetcher-error.js';
+export { resolveErrorMessage, constructDisplayMessage, } from './errors/messages.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../lib/fetcher/utils/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG9D,OAAO,EAAE,4BAA4B,EAAE,MAAM,qCAAqC,CAAC;AAEnF,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EACL,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,sBAAsB,CAAC"}

package/dist/fetcher/utils/log-timestamp-normalization-warnings.d.ts

@@ -0,0 +1,10 @@
+import type { Logger } from '../../logger/index.js';
+import type { NormalizedPrototype } from '../../types/index.js';
+import type { UpstreamPrototype } from '../types/prototype-api.types.js';
+export declare function logTimestampNormalizationWarnings(params: {
+    logger: Logger;
+    original: UpstreamPrototype;
+    normalized: NormalizedPrototype;
+    index: number;
+}): void;
+//# sourceMappingURL=log-timestamp-normalization-warnings.d.ts.map

package/dist/fetcher/utils/log-timestamp-normalization-warnings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-timestamp-normalization-warnings.d.ts","sourceRoot":"","sources":["../../../lib/fetcher/utils/log-timestamp-normalization-warnings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAEzE,wBAAgB,iCAAiC,CAAC,MAAM,EAAE;IACxD,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,UAAU,EAAE,mBAAmB,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,IAAI,CAwCP"}

package/dist/fetcher/utils/log-timestamp-normalization-warnings.js

@@ -0,0 +1,32 @@
+export function logTimestampNormalizationWarnings(params) {
+    const { logger, original, normalized, index } = params;
+    // Check for date normalization failures.
+    // If the normalized value is the same as the original (and not null/undefined)
+    // but doesn't look like a normalized UTC ISO string (ending in 'Z'), it likely failed parsing.
+    const context = { prototypeId: original.id, index };
+    if (original.createDate &&
+        normalized.createDate === original.createDate &&
+        !normalized.createDate.endsWith('Z')) {
+        logger.warn('Failed to parse and normalize createDate', {
+            ...context,
+            originalValue: original.createDate,
+        });
+    }
+    if (original.updateDate &&
+        normalized.updateDate === original.updateDate &&
+        !normalized.updateDate.endsWith('Z')) {
+        logger.warn('Failed to parse and normalize updateDate', {
+            ...context,
+            originalValue: original.updateDate,
+        });
+    }
+    if (original.releaseDate &&
+        normalized.releaseDate === original.releaseDate &&
+        !normalized.releaseDate.endsWith('Z')) {
+        logger.warn('Failed to parse and normalize releaseDate', {
+            ...context,
+            originalValue: original.releaseDate,
+        });
+    }
+}
+//# sourceMappingURL=log-timestamp-normalization-warnings.js.map

package/dist/fetcher/utils/log-timestamp-normalization-warnings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-timestamp-normalization-warnings.js","sourceRoot":"","sources":["../../../lib/fetcher/utils/log-timestamp-normalization-warnings.ts"],"names":[],"mappings":"AAIA,MAAM,UAAU,iCAAiC,CAAC,MAKjD;IACC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;IAEvD,yCAAyC;IACzC,+EAA+E;IAC/E,+FAA+F;IAC/F,MAAM,OAAO,GAAG,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC;IAEpD,IACE,QAAQ,CAAC,UAAU;QACnB,UAAU,CAAC,UAAU,KAAK,QAAQ,CAAC,UAAU;QAC7C,CAAC,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,EACpC,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,0CAA0C,EAAE;YACtD,GAAG,OAAO;YACV,aAAa,EAAE,QAAQ,CAAC,UAAU;SACnC,CAAC,CAAC;IACL,CAAC;IAED,IACE,QAAQ,CAAC,UAAU;QACnB,UAAU,CAAC,UAAU,KAAK,QAAQ,CAAC,UAAU;QAC7C,CAAC,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,EACpC,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,0CAA0C,EAAE;YACtD,GAAG,OAAO;YACV,aAAa,EAAE,QAAQ,CAAC,UAAU;SACnC,CAAC,CAAC;IACL,CAAC;IAED,IACE,QAAQ,CAAC,WAAW;QACpB,UAAU,CAAC,WAAW,KAAK,QAAQ,CAAC,WAAW;QAC/C,CAAC,UAAU,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,EACrC,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,2CAA2C,EAAE;YACvD,GAAG,OAAO;YACV,aAAa,EAAE,QAAQ,CAAC,WAAW;SACpC,CAAC,CAAC;IACL,CAAC;AACH,CAAC"}

package/dist/fetcher/utils/normalize-protopedia-timestamp.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Timestamp normalization utilities for ProtoPedia.
+ *
+ * @module utils/time/normalize
+ */
+/**
+ * Normalize ProtoPedia timestamps to UTC ISO strings.
+ *
+ * This function attempts to parse timestamps using multiple strategies:
+ *
+ * 1. **ProtoPedia format** (`parseProtoPediaTimestamp`):
+ *    - Current format: `YYYY-MM-DD HH:MM:SS.0` (space separator, `.0` for zero milliseconds)
+ *    - Accepts variable-length fractional seconds for future compatibility
+ *    - Timezone: Always treated as JST (UTC+9)
+ *    - Returns UTC ISO string with JST offset subtracted
+ *
+ * 2. **W3C-DTF with timezone** (`parseW3cDtfTimestamp`):
+ *    - Accepts W3C-DTF Level 4-6 formats with mandatory timezone designator (TZD)
+ *    - Examples: `2025-11-14T12:03Z`, `2025-11-14T12:03:07+09:00`
+ *    - Returns UTC ISO string
+ *    - **Does NOT accept** timezone-less formats or offset without colon
+ *
+ * 3. **Passthrough**:
+ *    - If both parsers fail, returns the input value as-is
+ *    - Allows downstream code to handle or log unexpected formats
+ *
+ * **Special cases**:
+ * - `null` input → `null` output (preserves explicit null in API responses)
+ * - `undefined` input → `undefined` output (preserves field absence)
+ * - Empty string or invalid format → returned as-is
+ *
+ * **Testing note**:
+ * This function is primarily tested through integration scenarios.
+ * Detailed format validation and edge cases are covered by unit tests
+ * for `parseProtoPediaTimestamp` and `parseW3cDtfTimestamp`.
+ *
+ * @param value - Timestamp string, null, or undefined from API response
+ * @returns UTC ISO string, null, undefined, or original value
+ *
+ * @example
+ * ```typescript
+ * // ProtoPedia format (JST)
+ * normalizeProtoPediaTimestamp('2025-11-14 12:03:07.0')
+ * // => '2025-11-14T03:03:07.000Z'
+ *
+ * // ISO 8601 with timezone
+ * normalizeProtoPediaTimestamp('2025-11-14T12:03:07+09:00')
+ * // => '2025-11-14T03:03:07.000Z'
+ *
+ * // null/undefined preservation
+ * normalizeProtoPediaTimestamp(null) // => null
+ * normalizeProtoPediaTimestamp(undefined) // => undefined
+ *
+ * // Invalid format passthrough
+ * normalizeProtoPediaTimestamp('invalid') // => 'invalid'
+ * ```
+ */
+export declare function normalizeProtoPediaTimestamp(value: string | null | undefined): string | null | undefined;
+//# sourceMappingURL=normalize-protopedia-timestamp.d.ts.map

package/dist/fetcher/utils/normalize-protopedia-timestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-protopedia-timestamp.d.ts","sourceRoot":"","sources":["../../../lib/fetcher/utils/normalize-protopedia-timestamp.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,MAAM,GAAG,IAAI,GAAG,SAAS,CAuB3B"}

package/dist/fetcher/utils/normalize-protopedia-timestamp.js

@@ -0,0 +1,81 @@
+/**
+ * Timestamp normalization utilities for ProtoPedia.
+ *
+ * @module utils/time/normalize
+ */
+import { parseProtoPediaTimestamp } from '../../utils/time/parser.js';
+import { parseW3cDtfTimestamp } from '../../utils/time/parser.js';
+/**
+ * Normalize ProtoPedia timestamps to UTC ISO strings.
+ *
+ * This function attempts to parse timestamps using multiple strategies:
+ *
+ * 1. **ProtoPedia format** (`parseProtoPediaTimestamp`):
+ *    - Current format: `YYYY-MM-DD HH:MM:SS.0` (space separator, `.0` for zero milliseconds)
+ *    - Accepts variable-length fractional seconds for future compatibility
+ *    - Timezone: Always treated as JST (UTC+9)
+ *    - Returns UTC ISO string with JST offset subtracted
+ *
+ * 2. **W3C-DTF with timezone** (`parseW3cDtfTimestamp`):
+ *    - Accepts W3C-DTF Level 4-6 formats with mandatory timezone designator (TZD)
+ *    - Examples: `2025-11-14T12:03Z`, `2025-11-14T12:03:07+09:00`
+ *    - Returns UTC ISO string
+ *    - **Does NOT accept** timezone-less formats or offset without colon
+ *
+ * 3. **Passthrough**:
+ *    - If both parsers fail, returns the input value as-is
+ *    - Allows downstream code to handle or log unexpected formats
+ *
+ * **Special cases**:
+ * - `null` input → `null` output (preserves explicit null in API responses)
+ * - `undefined` input → `undefined` output (preserves field absence)
+ * - Empty string or invalid format → returned as-is
+ *
+ * **Testing note**:
+ * This function is primarily tested through integration scenarios.
+ * Detailed format validation and edge cases are covered by unit tests
+ * for `parseProtoPediaTimestamp` and `parseW3cDtfTimestamp`.
+ *
+ * @param value - Timestamp string, null, or undefined from API response
+ * @returns UTC ISO string, null, undefined, or original value
+ *
+ * @example
+ * ```typescript
+ * // ProtoPedia format (JST)
+ * normalizeProtoPediaTimestamp('2025-11-14 12:03:07.0')
+ * // => '2025-11-14T03:03:07.000Z'
+ *
+ * // ISO 8601 with timezone
+ * normalizeProtoPediaTimestamp('2025-11-14T12:03:07+09:00')
+ * // => '2025-11-14T03:03:07.000Z'
+ *
+ * // null/undefined preservation
+ * normalizeProtoPediaTimestamp(null) // => null
+ * normalizeProtoPediaTimestamp(undefined) // => undefined
+ *
+ * // Invalid format passthrough
+ * normalizeProtoPediaTimestamp('invalid') // => 'invalid'
+ * ```
+ */
+export function normalizeProtoPediaTimestamp(value) {
+    // Preserve null/undefined as-is
+    if (value === null) {
+        return null;
+    }
+    if (value === undefined) {
+        return undefined;
+    }
+    // Try ProtoPedia format first (JST-based, strict format)
+    const protoPediaResult = parseProtoPediaTimestamp(value);
+    if (protoPediaResult !== undefined) {
+        return protoPediaResult;
+    }
+    // Fall back to W3C-DTF parsing (handles ISO 8601 with explicit timezone)
+    const w3cDtfResult = parseW3cDtfTimestamp(value);
+    if (w3cDtfResult !== undefined) {
+        return w3cDtfResult;
+    }
+    // Return as-is if unparseable (allows downstream handling)
+    return value;
+}
+//# sourceMappingURL=normalize-protopedia-timestamp.js.map

package/dist/fetcher/utils/normalize-protopedia-timestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-protopedia-timestamp.js","sourceRoot":"","sources":["../../../lib/fetcher/utils/normalize-protopedia-timestamp.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAM,UAAU,4BAA4B,CAC1C,KAAgC;IAEhC,gCAAgC;IAChC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,yDAAyD;IACzD,MAAM,gBAAgB,GAAG,wBAAwB,CAAC,KAAK,CAAC,CAAC;IACzD,IAAI,gBAAgB,KAAK,SAAS,EAAE,CAAC;QACnC,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED,yEAAyE;IACzE,MAAM,YAAY,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;IACjD,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;QAC/B,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,2DAA2D;IAC3D,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/fetcher/utils/normalize-prototype.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Prototype normalization utilities for ProtoPedia API responses.
+ *
+ * @module fetcher/utils/normalize-prototype
+ */
+import type { NormalizedPrototype } from '../../types/index.js';
+import type { UpstreamPrototype } from '../types/prototype-api.types.js';
+/**
+ * Transform an upstream prototype object into the normalized shape.
+ *
+ * This function maps all fields from {@link UpstreamPrototype} to
+ * {@link NormalizedPrototype}, applying the following transformations:
+ *
+ * **Pipe-separated fields** (split into trimmed arrays):
+ * - tags, users, awards, events, materials
+ * - Uses {@link splitPipeSeparatedString}
+ * - Empty segments filtered out
+ * - null/undefined → empty array
+ *
+ * **Timestamp fields** (normalized to UTC ISO strings):
+ * - createDate, updateDate: ProtoPedia JST format → UTC
+ * - releaseDate: ProtoPedia JST format → UTC, null/undefined → undefined
+ * - Uses {@link normalizeProtoPediaTimestamp}
+ * - Fallback to original string if parsing fails
+ *
+ * **Optional fields** (default values when null/undefined):
+ * - releaseFlg: 2 (Released)
+ * - revision: 0
+ * - licenseType: 1
+ * - thanksFlg: 0
+ * - String fields (summary, freeComment, etc.): ''
+ *
+ * **Other fields**: Copied as-is
+ *
+ * @param prototype - The raw prototype object from the ProtoPedia API.
+ * @returns A {@link NormalizedPrototype} instance with all fields normalized.
+ *
+ * @example
+ * ```ts
+ * const upstream: UpstreamPrototype = {
+ *   id: 123,
+ *   prototypeNm: 'My Project',
+ *   tags: 'IoT | AI | Robotics',
+ *   users: 'user1|user2',
+ *   createDate: '2024-01-01 12:00:00.0',
+ *   // ...other fields
+ * };
+ *
+ * const normalized = normalizePrototype(upstream);
+ * // normalized.tags => ['IoT', 'AI', 'Robotics']
+ * // normalized.users => ['user1', 'user2']
+ * // normalized.createDate => '2024-01-01T03:00:00.000Z' (JST → UTC)
+ * ```
+ */
+export declare function normalizePrototype(p: UpstreamPrototype): NormalizedPrototype;
+//# sourceMappingURL=normalize-prototype.d.ts.map

package/dist/fetcher/utils/normalize-prototype.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-prototype.d.ts","sourceRoot":"","sources":["../../../lib/fetcher/utils/normalize-prototype.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAEV,mBAAmB,EAIpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAKzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,iBAAiB,GAAG,mBAAmB,CA4E5E"}

package/dist/fetcher/utils/normalize-prototype.js

@@ -0,0 +1,113 @@
+import { normalizeProtoPediaTimestamp } from './normalize-protopedia-timestamp.js';
+import { splitPipeSeparatedString } from './string-parsers.js';
+/**
+ * Transform an upstream prototype object into the normalized shape.
+ *
+ * This function maps all fields from {@link UpstreamPrototype} to
+ * {@link NormalizedPrototype}, applying the following transformations:
+ *
+ * **Pipe-separated fields** (split into trimmed arrays):
+ * - tags, users, awards, events, materials
+ * - Uses {@link splitPipeSeparatedString}
+ * - Empty segments filtered out
+ * - null/undefined → empty array
+ *
+ * **Timestamp fields** (normalized to UTC ISO strings):
+ * - createDate, updateDate: ProtoPedia JST format → UTC
+ * - releaseDate: ProtoPedia JST format → UTC, null/undefined → undefined
+ * - Uses {@link normalizeProtoPediaTimestamp}
+ * - Fallback to original string if parsing fails
+ *
+ * **Optional fields** (default values when null/undefined):
+ * - releaseFlg: 2 (Released)
+ * - revision: 0
+ * - licenseType: 1
+ * - thanksFlg: 0
+ * - String fields (summary, freeComment, etc.): ''
+ *
+ * **Other fields**: Copied as-is
+ *
+ * @param prototype - The raw prototype object from the ProtoPedia API.
+ * @returns A {@link NormalizedPrototype} instance with all fields normalized.
+ *
+ * @example
+ * ```ts
+ * const upstream: UpstreamPrototype = {
+ *   id: 123,
+ *   prototypeNm: 'My Project',
+ *   tags: 'IoT | AI | Robotics',
+ *   users: 'user1|user2',
+ *   createDate: '2024-01-01 12:00:00.0',
+ *   // ...other fields
+ * };
+ *
+ * const normalized = normalizePrototype(upstream);
+ * // normalized.tags => ['IoT', 'AI', 'Robotics']
+ * // normalized.users => ['user1', 'user2']
+ * // normalized.createDate => '2024-01-01T03:00:00.000Z' (JST → UTC)
+ * ```
+ */
+export function normalizePrototype(p) {
+    // Precompute adjusted date fields
+    // createDate: Required field - preserve original value if parsing fails
+    // Always ProtoPedia format → UTC ISO string
+    const adjustedCreateDate = normalizeProtoPediaTimestamp(p.createDate) ?? p.createDate;
+    // updateDate: Optional field - preserve original value if parsing fails
+    // Always ProtoPedia format → UTC ISO string
+    const adjustedUpdateDate = normalizeProtoPediaTimestamp(p.updateDate) ?? p.updateDate;
+    // releaseDate: Optional field - drop to undefined if parsing fails
+    // This differs from createDate/updateDate: unparseable release dates
+    // are treated as invalid/missing data rather than preserved as-is
+    // ProtoPedia format → UTC ISO string, null or undefined → undefined
+    const adjustedReleaseDate = normalizeProtoPediaTimestamp(p.releaseDate) ?? undefined;
+    const normalized = {
+        /* ID */
+        id: p.id,
+        /* Editorial information  */
+        createDate: adjustedCreateDate,
+        updateDate: adjustedUpdateDate,
+        releaseDate: adjustedReleaseDate,
+        createId: p.createId,
+        updateId: p.updateId,
+        releaseFlg: (p.releaseFlg ??
+            2) /* Default to 'Released' */,
+        /* Basic information */
+        status: p.status,
+        prototypeNm: p.prototypeNm,
+        summary: p.summary ?? '' /* Default to empty string */,
+        freeComment: p.freeComment ?? '' /* Default to empty string */,
+        systemDescription: p.systemDescription ?? '' /* Default to empty string */,
+        /** Users and Team */
+        users: splitPipeSeparatedString(p.users),
+        teamNm: p.teamNm ?? '' /* Default to empty string */,
+        /** Tags, Materials, Events, and Awards */
+        tags: splitPipeSeparatedString(p.tags),
+        materials: splitPipeSeparatedString(p.materials),
+        events: splitPipeSeparatedString(p.events),
+        awards: splitPipeSeparatedString(p.awards),
+        /* URLs */
+        officialLink: p.officialLink,
+        videoUrl: p.videoUrl,
+        mainUrl: p.mainUrl,
+        relatedLink: p.relatedLink,
+        relatedLink2: p.relatedLink2,
+        relatedLink3: p.relatedLink3,
+        relatedLink4: p.relatedLink4,
+        relatedLink5: p.relatedLink5,
+        /* counts */
+        viewCount: p.viewCount,
+        goodCount: p.goodCount,
+        commentCount: p.commentCount,
+        /* Others */
+        uuid: p.uuid,
+        nid: p.nid,
+        revision: p.revision ?? 0 /* Default to 0 */,
+        licenseType: (p.licenseType ??
+            1) /* Default to 1(表示(CC:BY)) */,
+        thanksFlg: (p.thanksFlg ??
+            0) /* Default to 0(Message not yet shown) */,
+        slideMode: p.slideMode,
+    };
+    return normalized;
+}
+//# sourceMappingURL=normalize-prototype.js.map

package/dist/fetcher/utils/normalize-prototype.js.map

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

package/dist/fetcher/utils/sanitize-options.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Utilities for sanitizing API client options.
+ *
+ * @module
+ */
+import type { ProtoPediaApiClientOptions } from 'protopedia-api-v2-client';
+/**
+ * Sanitizes ProtopediaApiClientOptions for logging by redacting the token.
+ *
+ * @param options The options object to sanitize.
+ * @returns A new options object with the token redacted.
+ */
+export declare function sanitizeProtopediaApiClientOptions(options: ProtoPediaApiClientOptions | undefined): ProtoPediaApiClientOptions | undefined;
+//# sourceMappingURL=sanitize-options.d.ts.map

package/dist/fetcher/utils/sanitize-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize-options.d.ts","sourceRoot":"","sources":["../../../lib/fetcher/utils/sanitize-options.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AAE3E;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,0BAA0B,GAAG,SAAS,GAC9C,0BAA0B,GAAG,SAAS,CAQxC"}

package/dist/fetcher/utils/sanitize-options.js

@@ -0,0 +1,16 @@
+/**
+ * Sanitizes ProtopediaApiClientOptions for logging by redacting the token.
+ *
+ * @param options The options object to sanitize.
+ * @returns A new options object with the token redacted.
+ */
+export function sanitizeProtopediaApiClientOptions(options) {
+    if (!options) {
+        return undefined;
+    }
+    if (options.token) {
+        return { ...options, token: '***' };
+    }
+    return options;
+}
+//# sourceMappingURL=sanitize-options.js.map

package/dist/fetcher/utils/sanitize-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize-options.js","sourceRoot":"","sources":["../../../lib/fetcher/utils/sanitize-options.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,MAAM,UAAU,kCAAkC,CAChD,OAA+C;IAE/C,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QAClB,OAAO,EAAE,GAAG,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IACtC,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/fetcher/utils/string-parsers.d.ts

@@ -0,0 +1,45 @@
+/**
+ * String parsing utilities for ProtoPedia API responses.
+ *
+ * @module fetcher/utils/string-parsers
+ */
+/**
+ * Split a pipe-separated string into an array of trimmed segments.
+ *
+ * The ProtoPedia API returns certain fields (tags, users, awards, events,
+ * materials) as pipe-delimited strings. This helper parses such a string
+ * into a clean array.
+ *
+ * **Behavior:**
+ * - Splits by pipe character (`|`)
+ * - Trims whitespace from each segment
+ * - **Filters out empty segments** (empty strings after trimming)
+ * - Returns empty array for null, undefined, or empty string input
+ *
+ * @param value - The pipe-separated string to split. Returns empty array
+ *   for null, undefined, or empty string.
+ * @returns An array of non-empty trimmed string segments.
+ *
+ * @example
+ * ```ts
+ * splitPipeSeparatedString('tag1|tag2|tag3');
+ * // => ['tag1', 'tag2', 'tag3']
+ *
+ * splitPipeSeparatedString('tag1 | tag2');
+ * // => ['tag1', 'tag2'] (whitespace trimmed)
+ *
+ * splitPipeSeparatedString('a||b');
+ * // => ['a', 'b'] (empty segment filtered out)
+ *
+ * splitPipeSeparatedString('tag1|  |tag2');
+ * // => ['tag1', 'tag2'] (whitespace-only segment filtered out)
+ *
+ * splitPipeSeparatedString('');
+ * // => []
+ *
+ * splitPipeSeparatedString(null);
+ * // => []
+ * ```
+ */
+export declare const splitPipeSeparatedString: (value: string | null | undefined) => string[];
+//# sourceMappingURL=string-parsers.d.ts.map

package/dist/fetcher/utils/string-parsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-parsers.d.ts","sourceRoot":"","sources":["../../../lib/fetcher/utils/string-parsers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,wBAAwB,GACnC,OAAO,MAAM,GAAG,IAAI,GAAG,SAAS,KAC/B,MAAM,EAQR,CAAC"}

package/dist/fetcher/utils/string-parsers.js

@@ -0,0 +1,53 @@
+/**
+ * String parsing utilities for ProtoPedia API responses.
+ *
+ * @module fetcher/utils/string-parsers
+ */
+/**
+ * Split a pipe-separated string into an array of trimmed segments.
+ *
+ * The ProtoPedia API returns certain fields (tags, users, awards, events,
+ * materials) as pipe-delimited strings. This helper parses such a string
+ * into a clean array.
+ *
+ * **Behavior:**
+ * - Splits by pipe character (`|`)
+ * - Trims whitespace from each segment
+ * - **Filters out empty segments** (empty strings after trimming)
+ * - Returns empty array for null, undefined, or empty string input
+ *
+ * @param value - The pipe-separated string to split. Returns empty array
+ *   for null, undefined, or empty string.
+ * @returns An array of non-empty trimmed string segments.
+ *
+ * @example
+ * ```ts
+ * splitPipeSeparatedString('tag1|tag2|tag3');
+ * // => ['tag1', 'tag2', 'tag3']
+ *
+ * splitPipeSeparatedString('tag1 | tag2');
+ * // => ['tag1', 'tag2'] (whitespace trimmed)
+ *
+ * splitPipeSeparatedString('a||b');
+ * // => ['a', 'b'] (empty segment filtered out)
+ *
+ * splitPipeSeparatedString('tag1|  |tag2');
+ * // => ['tag1', 'tag2'] (whitespace-only segment filtered out)
+ *
+ * splitPipeSeparatedString('');
+ * // => []
+ *
+ * splitPipeSeparatedString(null);
+ * // => []
+ * ```
+ */
+export const splitPipeSeparatedString = (value) => {
+    if (typeof value !== 'string' || value.length === 0) {
+        return [];
+    }
+    return value
+        .split('|')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+};
+//# sourceMappingURL=string-parsers.js.map

package/dist/fetcher/utils/string-parsers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-parsers.js","sourceRoot":"","sources":["../../../lib/fetcher/utils/string-parsers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CACtC,KAAgC,EACtB,EAAE;IACZ,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACpD,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,OAAO,KAAK;SACT,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;SACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACjC,CAAC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Public entrypoint for the promidas library.
+ *
+ * ## Quick Start
+ *
+ * For most use cases, use the Builder to create a Repository:
+ *
+ * @example
+ * ```typescript
+ * import { PromidasRepositoryBuilder } from 'promidas';
+ *
+ * const repo = new PromidasRepositoryBuilder()
+ *   .setStoreConfig({ ttlMs: 30 * 60 * 1000 })
+ *   .setApiClientConfig({
+ *     protoPediaApiClientOptions: { token: process.env.PROTOPEDIA_API_V2_TOKEN }
+ *   })
+ *   .build();
+ *
+ * await repo.setupSnapshot({ limit: 100 });
+ * const prototype = await repo.getRandomPrototypeFromSnapshot();
+ * ```
+ *
+ * ## Standalone Module Usage
+ *
+ * For advanced use cases or when you need specific modules independently,
+ * use subpath imports:
+ *
+ * @example
+ * ```typescript
+ * // Type definitions
+ * import type { NormalizedPrototype } from 'promidas/types';
+ *
+ * // Utility functions and converters
+ * import {
+ *   parseProtoPediaTimestamp,
+ *   getPrototypeStatusLabel
+ * } from 'promidas/utils';
+ *
+ * // Logger interface and implementations
+ * import { createConsoleLogger } from 'promidas/logger';
+ *
+ * // API client and data fetching
+ * import {
+ *   ProtopediaApiCustomClient
+ * } from 'promidas/fetcher';
+ *
+ * // In-memory store
+ * import { PrototypeInMemoryStore } from 'promidas/store';
+ *
+ * // Repository builder
+ * import { PromidasRepositoryBuilder } from 'promidas';
+ * ```
+ *
+ * ## Available Subpath Exports
+ *
+ * - `promidas/types` — Type definitions (NormalizedPrototype)
+ * - `promidas/utils` — Utility functions and converters
+ * - `promidas/logger` — Logger interface and implementations
+ * - `promidas/fetcher` — API client and data fetching utilities
+ * - `promidas/store` — In-memory store implementation
+ *
+ * @packageDocumentation
+ */
+export { PromidasRepositoryBuilder, type PrototypeInMemoryStoreConfig, type PrototypeInMemoryStats, type ProtoPediaApiClientOptions, type ProtopediaInMemoryRepository, type ProtopediaInMemoryRepositoryConfig, } from './builder.js';
+export { createPromidasForLocal, createPromidasForServer } from './factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAGH,OAAO,EAEL,yBAAyB,EAGzB,KAAK,4BAA4B,EACjC,KAAK,sBAAsB,EAO3B,KAAK,0BAA0B,EAG/B,KAAK,4BAA4B,EACjC,KAAK,kCAAkC,GACxC,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC"}