@maixio/pstore 0.1.0

package/dist/api/catalog-discovery.d.ts

@@ -0,0 +1,40 @@
+import type { PsnLocale } from "../types.js";
+export interface CatalogDiscoveryPage {
+    alias: string;
+    url: string;
+    depth: number;
+    title?: string;
+}
+export interface CatalogDiscoveryCatalog {
+    id: string;
+    url: string;
+    depth: number;
+    label?: string;
+    displayName?: string;
+    localizedName?: string;
+    reportingName?: string;
+    sourcePageAlias?: string;
+}
+export interface CatalogDiscoveryResult {
+    pages: CatalogDiscoveryPage[];
+    catalogs: CatalogDiscoveryCatalog[];
+}
+export interface DiscoverCatalogsOptions {
+    locale?: PsnLocale;
+    maxDepth?: number;
+    concurrency?: number;
+    maxPages?: number;
+    maxCatalogs?: number;
+}
+export declare function discoverCatalogs(opts?: DiscoverCatalogsOptions): Promise<CatalogDiscoveryResult>;
+export declare function extractPageAliases(html: string): string[];
+export declare function extractCategoryIds(html: string): string[];
+export declare function extractCategoryTitles(html: string): Map<string, string>;
+export interface CategoryDiscoveryMetadata {
+    id: string;
+    displayName?: string;
+    localizedName?: string;
+    reportingName?: string;
+}
+export declare function extractCategoryMetadata(html: string, locale?: PsnLocale): Map<string, CategoryDiscoveryMetadata>;
+export declare function extractPageTitle(html: string): string | undefined;

package/dist/api/catalog-registry.d.ts

@@ -0,0 +1,21 @@
+import type { PsnLocale } from "../types.js";
+export type CatalogRegistrySource = "built-in" | "manual" | "live" | "validated";
+export type CatalogVisibility = "visible" | "hidden" | "unknown";
+export interface CatalogRegistryEntry {
+    id: string;
+    alias: string;
+    localizedName?: string;
+    displayName?: Partial<Record<PsnLocale, string>> & {
+        default?: string;
+    };
+    visibility?: Partial<Record<PsnLocale, CatalogVisibility>> & {
+        default?: CatalogVisibility;
+    };
+    source: CatalogRegistrySource;
+    notes?: string;
+}
+export declare const BUILTIN_CATALOGS: CatalogRegistryEntry[];
+export declare const CATALOG_ALIASES: Record<string, string>;
+export declare function resolveCatalogAlias(input: string): CatalogRegistryEntry | undefined;
+export declare function resolveCatalogDisplayName(entry: CatalogRegistryEntry, locale?: PsnLocale): string | undefined;
+export declare function resolveCatalogVisibility(entry: CatalogRegistryEntry, locale?: PsnLocale): CatalogVisibility;

package/dist/api/catalog-validation.d.ts

@@ -0,0 +1,21 @@
+import type { PsnLocale } from "../types.js";
+import { type CatalogRegistryEntry } from "./catalog-registry.js";
+export interface CatalogValidationOptions {
+    locale?: PsnLocale;
+    entries?: CatalogRegistryEntry[];
+    size?: number;
+}
+export interface CatalogValidationResult {
+    alias: string;
+    id: string;
+    locale: PsnLocale;
+    ok: boolean;
+    totalCount?: number;
+    itemCount?: number;
+    localizedName?: string;
+    displayName?: string;
+    reportingName?: string;
+    error?: string;
+}
+export declare function validateCatalog(entry: CatalogRegistryEntry, options?: Omit<CatalogValidationOptions, "entries">): Promise<CatalogValidationResult>;
+export declare function validateCatalogs(options?: CatalogValidationOptions): Promise<CatalogValidationResult[]>;

package/dist/api/category-names.d.ts

@@ -0,0 +1,2 @@
+import type { PsnLocale } from "../types.js";
+export declare function resolveCategoryDisplayName(localizedName?: string | null, locale?: PsnLocale): string | undefined;

package/dist/api/graphql.d.ts

@@ -0,0 +1,216 @@
+import type { ConceptId, ProductId, PsnLocale, Price, StarRating, ContentRating } from "../types.js";
+export interface TelemetryResult {
+    idType?: "concept" | "product";
+    conceptId: string;
+    productId?: string;
+    name?: string;
+    productName?: string;
+    edition?: string;
+    genres?: string[];
+    skus?: Array<{
+        id: string;
+        name: string;
+        displayPrice?: string;
+        price?: number;
+        type?: string;
+    }>;
+    starRating?: {
+        averageRating: number;
+    };
+    price?: {
+        basePrice?: string | null;
+        basePriceValue?: number | null;
+        discountedPrice?: string | null;
+        discountedValue?: number | null;
+        discountText?: string | null;
+        currencyCode?: string | null;
+        endTime?: string | null;
+    };
+    npTitleId?: string;
+    classification?: string;
+    topCategory?: string;
+    platforms?: string[];
+    releaseDate?: string;
+    contentRating?: ContentRating | null;
+}
+export declare function fetchTelemetry(conceptId: ConceptId, locale?: string): Promise<TelemetryResult | null>;
+export declare function fetchTelemetryByProduct(productId: ProductId, locale?: string): Promise<TelemetryResult | null>;
+export interface PriceResult {
+    price?: Price;
+    conceptId?: string;
+    productId?: string;
+    products?: Array<{
+        id: string;
+        name?: string;
+        edition?: string;
+    }>;
+}
+export declare function fetchPrice(conceptId: ConceptId, locale?: string): Promise<PriceResult | null>;
+export declare function fetchPriceByProduct(productId: ProductId, locale?: string): Promise<PriceResult | null>;
+export interface RatingResult {
+    conceptId?: string;
+    productId?: string;
+    name?: string;
+    starRating?: StarRating;
+    classification?: string;
+    topCategory?: string;
+    releaseDate?: string;
+}
+export declare function fetchRating(conceptId: ConceptId, locale?: string): Promise<RatingResult | null>;
+export declare function fetchRatingByProduct(productId: ProductId, locale?: string): Promise<RatingResult | null>;
+export interface UpsellResult {
+    conceptId?: string;
+    productId?: string;
+    media?: Array<{
+        role: string;
+        type: string;
+        url: string;
+    }>;
+    products?: Array<{
+        id: string;
+        name?: string;
+        edition?: string;
+        editionType?: string;
+        platforms?: string[];
+        classification?: string;
+        price?: Price;
+        media?: Array<{
+            role: string;
+            type: string;
+            url: string;
+        }>;
+    }>;
+}
+export declare function fetchUpsell(conceptId: ConceptId, locale?: string): Promise<UpsellResult | null>;
+export declare function fetchUpsellByProduct(productId: ProductId, locale?: string): Promise<UpsellResult | null>;
+export interface SearchParams {
+    searchTerm: string;
+    countryCode?: string;
+    languageCode?: string;
+    pageSize?: number;
+    pageOffset?: number;
+    nextCursor?: string;
+}
+export interface SearchResultItem {
+    id: string;
+    name: string;
+    type: "concept" | "product";
+    price?: string;
+    platforms?: string[];
+    classification?: string;
+}
+export interface SearchResponseData {
+    universalSearch?: {
+        results?: Array<Record<string, unknown>>;
+    };
+    [key: string]: unknown;
+}
+export declare function fetchSearchResults(params: SearchParams): Promise<SearchResultItem[] | null>;
+export declare function parseSearchResults(data: SearchResponseData | null | undefined): SearchResultItem[];
+export interface CategoryGridParams {
+    id: string;
+    offset?: number;
+    size?: number;
+    sortBy?: string | Record<string, unknown> | null;
+    filterBy?: string[];
+    maxResults?: number | null;
+    locale?: PsnLocale;
+}
+export interface CategoryGridItem {
+    id: string;
+    name: string;
+    type: "concept" | "product";
+    price?: string;
+    platforms?: string[];
+    classification?: string;
+}
+export interface CategoryGridPageInfo {
+    totalCount: number;
+    offset: number;
+    size: number;
+    isLast: boolean;
+}
+export interface CategorySortingOption {
+    name: string;
+    displayName?: string;
+    isAscending: boolean;
+}
+export interface CategoryFacetValue {
+    key: string;
+    displayName?: string;
+    count: number;
+}
+export interface CategoryFacet {
+    name: string;
+    displayName?: string;
+    values: CategoryFacetValue[];
+}
+export interface CategoryGridResult {
+    id: string;
+    localizedName?: string;
+    displayName?: string;
+    reportingName?: string;
+    pageInfo?: CategoryGridPageInfo;
+    sortedBy?: CategorySortingOption;
+    sortingOptions?: CategorySortingOption[];
+    facets?: CategoryFacet[];
+    items: CategoryGridItem[];
+}
+interface CategoryGridRawResponse {
+    categoryGridRetrieve?: {
+        concepts?: Array<{
+            __typename?: string;
+            id: string;
+            name?: string;
+            price?: {
+                basePrice?: string;
+                discountedPrice?: string;
+            };
+            platforms?: string[];
+            storeDisplayClassification?: string;
+            localizedStoreDisplayClassification?: string;
+        }>;
+        products?: Array<{
+            __typename?: string;
+            id: string;
+            name?: string;
+            displayPrice?: string;
+            platforms?: string[];
+            storeDisplayClassification?: string;
+            localizedStoreDisplayClassification?: string;
+        }>;
+        pageInfo?: {
+            totalCount: number;
+            offset: number;
+            size: number;
+            isLast: boolean;
+        };
+        sortedBy?: {
+            name: string;
+            displayName?: string;
+            isAscending: boolean;
+        };
+        sortingOptions?: Array<{
+            name: string;
+            displayName?: string;
+            isAscending: boolean;
+        }>;
+        facetOptions?: Array<{
+            name: string;
+            displayName?: string;
+            values?: Array<{
+                key: string;
+                displayName?: string;
+                count: number;
+            }>;
+        }>;
+        localizedName?: string;
+        reportingName?: string;
+    };
+}
+export declare function fetchCategoryGrid(params: CategoryGridParams): Promise<CategoryGridItem[] | null>;
+export declare function fetchCategoryGridResult(params: CategoryGridParams): Promise<CategoryGridResult | null>;
+export declare function parseCategoryGridResult(id: string, grid: NonNullable<CategoryGridRawResponse["categoryGridRetrieve"]>, locale?: PsnLocale): CategoryGridResult;
+export declare function parseCategoryGridItems(grid: NonNullable<CategoryGridRawResponse["categoryGridRetrieve"]>): CategoryGridItem[];
+export declare function clearCategoryCache(): void;
+export {};

package/dist/api/search.d.ts

@@ -0,0 +1,23 @@
+import type { PsnLocale } from "../types.js";
+import { type SearchResultItem } from "./graphql.js";
+export interface SearchOptions {
+    term: string;
+    locale?: PsnLocale;
+    page?: number;
+    size?: number;
+    nextCursor?: string;
+}
+export interface SearchResponse {
+    hits: SearchResultItem[];
+    page: number;
+    size: number;
+    nextCursor?: string;
+    isLast?: boolean;
+    total?: number;
+}
+/**
+ * Search PSN Store games.
+ */
+export declare function searchGames(options: SearchOptions): Promise<SearchResponse>;
+export declare function parseSearchResponse(rawData: Record<string, unknown> | null | undefined, page: number, size: number): SearchResponse;
+export declare function clearSearchCache(): void;

package/dist/api/status.d.ts

@@ -0,0 +1,81 @@
+import type { PsnLocale } from "../types.js";
+export type PsnStatusRegion = "SCEA" | "SCEE" | "SCEJA";
+export type PsnServiceStatus = "ok" | "degraded" | "maintenance" | "outage";
+export interface PsnStatusOptions {
+    locale?: PsnLocale;
+    region?: PsnStatusRegion;
+    country?: string;
+}
+export interface PsnStatusService {
+    id: string;
+    name: string;
+    status: PsnServiceStatus;
+    incidents: PsnStatusIncident[];
+    resources?: PsnStatusServiceResource[];
+}
+export interface PsnStatusServiceResource {
+    name: string;
+    status: PsnServiceStatus;
+    incidents: PsnStatusIncident[];
+}
+export interface PsnStatusIncident {
+    id?: string;
+    statusType: string;
+    message?: string;
+    startDate?: string;
+    modifiedDate?: string;
+}
+export interface PsnStatusResult {
+    region: PsnStatusRegion;
+    country: string;
+    locale: PsnLocale;
+    overallStatus: PsnServiceStatus;
+    generatedAt?: string;
+    updatedAt?: string;
+    refreshIntervalMs?: number;
+    services: PsnStatusService[];
+    incidents: PsnStatusIncident[];
+}
+interface RawStatusResponse {
+    regionName?: string;
+    generatedAt?: string;
+    status?: RawStatusEntry[];
+    countries?: RawCountryStatus[];
+}
+interface RawCountryStatus {
+    countryCode?: string;
+    countryName?: string;
+    status?: RawStatusEntry[];
+    services?: RawServiceStatus[];
+}
+interface RawServiceStatus {
+    serviceId?: string;
+    serviceName?: string;
+    i18n?: Record<string, string>;
+    status?: RawStatusEntry[];
+    resources?: RawServiceResource[];
+}
+interface RawServiceResource {
+    resourceName?: string;
+    i18n?: Record<string, string>;
+    status?: RawStatusEntry[];
+}
+interface RawStatusEntry {
+    statusId?: string;
+    statusType?: string;
+    startDate?: string;
+    modifiedDate?: string;
+    message?: {
+        messageKey?: string;
+        messages?: Record<string, string>;
+    };
+}
+export declare function fetchPsnStatus(options?: PsnStatusOptions): Promise<PsnStatusResult>;
+export declare function parsePsnStatus(raw: RawStatusResponse, context: {
+    locale: PsnLocale;
+    country: string;
+    region: PsnStatusRegion;
+    refreshIntervalMs?: number;
+}): PsnStatusResult;
+export declare function regionForCountry(country: string): PsnStatusRegion;
+export {};

package/dist/build-record.d.ts

@@ -0,0 +1,20 @@
+import type { LookupResult, PsnLocale, BatarangData, LookupWarning } from "./types.js";
+import type { TelemetryResult, PriceResult, RatingResult, UpsellResult } from "./api/graphql.js";
+export interface RawLookupData {
+    inputId?: string;
+    idType?: "concept" | "product";
+    telemetry?: TelemetryResult | null;
+    price?: PriceResult | null;
+    rating?: RatingResult | null;
+    upsell?: UpsellResult | null;
+    batarang?: BatarangData | null;
+    concept?: LookupResult | null;
+    locale?: PsnLocale;
+    timing?: Record<string, number>;
+    includeProducts?: boolean;
+    warnings?: LookupWarning[];
+}
+/**
+ * Build a unified LookupResult from raw API responses.
+ */
+export declare function buildLookupRecord(data: RawLookupData): LookupResult;

package/dist/cache.d.ts

@@ -0,0 +1,25 @@
+export declare class Cache<T> {
+    private store;
+    private readonly defaultTtl;
+    constructor(defaultTtlMs?: number);
+    /** Get a cached value. Returns undefined if missing or expired. */
+    get(key: string): T | undefined;
+    /** Set a cached value with optional TTL override. */
+    set(key: string, value: T, ttlMs?: number): void;
+    /** Check if a key exists and is still valid. */
+    has(key: string): boolean;
+    /** Delete a cached entry. */
+    delete(key: string): void;
+    /** Clear all cached entries. */
+    clear(): void;
+    /** Get the number of entries in the cache. */
+    get size(): number;
+}
+/** Cache TTL constants (in milliseconds) */
+export declare const TTL: {
+    readonly GAME_LOOKUP: number;
+    readonly PRODUCT_TO_CONCEPT: number;
+    readonly SEARCH: number;
+    readonly CATEGORY: number;
+    readonly BATARANG: number;
+};