@nice2dev/ui-tools 1.0.10

package/dist/traceless.d.ts

@@ -0,0 +1,759 @@
+/**
+ * @fileoverview SEC-008: Traceless™ — Zero-Trace Privacy Architecture
+ *
+ * "Your ERP. Zero traces. No cookie banners. Ever."
+ *
+ * This module provides TypeScript types and interfaces for the Traceless™
+ * privacy architecture - a flagship feature that allows enterprise applications
+ * to operate with zero client-side storage when required.
+ *
+ * @module @nice2dev/ui-tools/traceless
+ */
+/**
+ * Privacy mode levels from most restrictive to least restrictive.
+ *
+ * - `traceless`: Zero client-side storage. In-memory only. Full privacy.
+ * - `ephemeral`: sessionStorage only. Cleared on tab close.
+ * - `private`: sessionStorage + 1 httpOnly auth cookie.
+ * - `balanced`: sessionStorage + localStorage. No cookies.
+ * - `full`: All storage types including cookies. Requires consent banner.
+ * - `custom`: Manually configured storage permissions.
+ */
+export type TracelessMode = 'traceless' | 'ephemeral' | 'private' | 'balanced' | 'full' | 'custom';
+/**
+ * Storage capability flags for granular control.
+ */
+export interface StorageCapabilities {
+    /** Whether cookies are allowed */
+    cookiesAllowed: boolean;
+    /** Whether localStorage is allowed */
+    localStorageAllowed: boolean;
+    /** Whether sessionStorage is allowed */
+    sessionStorageAllowed: boolean;
+    /** Whether IndexedDB is allowed */
+    indexedDBAllowed?: boolean;
+    /** Whether Web SQL is allowed (deprecated but still used) */
+    webSQLAllowed?: boolean;
+    /** Whether Service Workers can cache data */
+    serviceWorkerCacheAllowed?: boolean;
+}
+/**
+ * Main Traceless Policy interface - injected per-request.
+ */
+export interface ITracelessPolicy extends StorageCapabilities {
+    /** Effective mode after resolution */
+    effectiveMode: TracelessMode;
+    /** Whether consent banner is required */
+    consentRequired: boolean;
+    /** Whether any form of persistence is allowed */
+    canPersist: boolean;
+    /** Source of the policy (instance, tenant, group, user) */
+    policySource: PolicySource;
+    /** Timestamp when policy was resolved */
+    resolvedAt: string;
+    /** Cache TTL in seconds */
+    cacheTTL?: number;
+}
+/**
+ * Source of the privacy policy in the hierarchy.
+ */
+export type PolicySource = 'instance' | 'tenant' | 'group' | 'user' | 'module' | 'computed';
+/**
+ * Instance-level ceiling - the maximum permissions any tenant can have.
+ */
+export interface InstanceStorageCeiling {
+    /** Maximum cookies permission for the instance */
+    maxCookies: boolean;
+    /** Maximum localStorage permission for the instance */
+    maxLocalStorage: boolean;
+    /** Maximum sessionStorage permission for the instance */
+    maxSessionStorage: boolean;
+    /** Maximum IndexedDB permission */
+    maxIndexedDB?: boolean;
+    /** Description of why ceiling is set this way */
+    reason?: string;
+    /** Who set this ceiling */
+    configuredBy?: string;
+    /** When ceiling was last modified */
+    lastModified?: string;
+}
+/**
+ * Tenant-level policy configuration.
+ */
+export interface TenantStoragePolicy {
+    /** Tenant identifier */
+    tenantId: string;
+    /** Tenant's chosen privacy mode (must be <= instance ceiling) */
+    mode: TracelessMode;
+    /** Override for cookies (cannot exceed instance ceiling) */
+    cookiesAllowed?: boolean;
+    /** Override for localStorage (cannot exceed instance ceiling) */
+    localStorageAllowed?: boolean;
+    /** Override for sessionStorage (cannot exceed instance ceiling) */
+    sessionStorageAllowed?: boolean;
+    /** Default mode for new users */
+    defaultUserMode?: TracelessMode;
+    /** Whether users can adjust their privacy level */
+    userAdjustmentAllowed: boolean;
+    /** Minimum mode users must have (cannot go more permissive) */
+    minimumUserMode?: TracelessMode;
+}
+/**
+ * User group policy configuration.
+ */
+export interface GroupStoragePolicy {
+    /** Group identifier */
+    groupId: string;
+    /** Group name for display */
+    groupName: string;
+    /** Privacy mode for this group */
+    mode: TracelessMode;
+    /** Custom storage capabilities for the group */
+    capabilities?: Partial<StorageCapabilities>;
+    /** Whether users in this group can adjust their level */
+    userAdjustmentAllowed: boolean;
+    /** Priority when user belongs to multiple groups */
+    priority: number;
+}
+/**
+ * User-level privacy preferences (self-lockdown).
+ */
+export interface UserPrivacyPreferences {
+    /** User identifier */
+    userId: string;
+    /** User's chosen mode (can only be more restrictive than group) */
+    mode: TracelessMode;
+    /** Custom restrictions */
+    restrictions?: Partial<StorageCapabilities>;
+    /** When user last modified their preferences */
+    lastModified: string;
+    /** Device-specific overrides */
+    deviceOverrides?: Record<string, TracelessMode>;
+}
+/**
+ * Module minimum storage requirements.
+ */
+export interface ModuleStorageRequirement {
+    /** Module identifier */
+    moduleId: string;
+    /** Module name */
+    moduleName: string;
+    /** Minimum storage needed for basic functionality */
+    minStorageRequirement: Partial<StorageCapabilities>;
+    /** Features that degrade gracefully without storage */
+    degradableFeatures: DegradableFeature[];
+    /** Features that are completely disabled without storage */
+    disabledFeatures: string[];
+    /** Warning message when storage is insufficient */
+    insufficientStorageWarning?: string;
+}
+/**
+ * A feature that can work with reduced functionality.
+ */
+export interface DegradableFeature {
+    /** Feature identifier */
+    featureId: string;
+    /** Feature name */
+    name: string;
+    /** Description of full functionality */
+    fullDescription: string;
+    /** Description of degraded functionality */
+    degradedDescription: string;
+    /** What storage is needed for full functionality */
+    requiredStorage: Partial<StorageCapabilities>;
+    /** Impact level when degraded */
+    degradedImpact: 'minor' | 'moderate' | 'significant';
+}
+/**
+ * Policy resolution request.
+ */
+export interface PolicyResolutionRequest {
+    /** Tenant context */
+    tenantId?: string;
+    /** User context */
+    userId?: string;
+    /** Device identifier for device-specific policies */
+    deviceId?: string;
+    /** Module requesting the policy */
+    moduleId?: string;
+    /** Whether to include detailed resolution trace */
+    includeTrace?: boolean;
+}
+/**
+ * Policy resolution response with computed policy.
+ */
+export interface PolicyResolutionResponse {
+    /** The computed effective policy */
+    policy: ITracelessPolicy;
+    /** Resolution trace showing how policy was computed */
+    trace?: PolicyResolutionTrace;
+    /** Warnings about capability limitations */
+    warnings?: PolicyWarning[];
+    /** Cache key for this resolution */
+    cacheKey?: string;
+}
+/**
+ * Trace of how policy was resolved through the hierarchy.
+ */
+export interface PolicyResolutionTrace {
+    /** Instance ceiling that was applied */
+    instanceCeiling: InstanceStorageCeiling;
+    /** Tenant policy that was applied */
+    tenantPolicy?: TenantStoragePolicy;
+    /** Group policies that were considered (in priority order) */
+    groupPolicies?: GroupStoragePolicy[];
+    /** User preferences that were applied */
+    userPreferences?: UserPrivacyPreferences;
+    /** Module requirements that were checked */
+    moduleRequirements?: ModuleStorageRequirement[];
+    /** Final computed result */
+    computedResult: ITracelessPolicy;
+    /** Resolution timestamp */
+    resolvedAt: string;
+}
+/**
+ * Warning about policy limitations.
+ */
+export interface PolicyWarning {
+    /** Warning code */
+    code: string;
+    /** Warning message */
+    message: string;
+    /** Severity of the warning */
+    severity: 'info' | 'warning' | 'error';
+    /** Affected module or feature */
+    affectedModule?: string;
+    /** Suggestion for resolution */
+    suggestion?: string;
+}
+/**
+ * Storage backend types.
+ */
+export type StorageBackend = 'memory' | 'sessionStorage' | 'localStorage' | 'indexedDB' | 'cookie';
+/**
+ * Unified Storage Adapter interface for all platforms.
+ */
+export interface IStorageAdapter {
+    /** Get a value by key */
+    get<T = unknown>(key: string): T | null;
+    /** Get a value asynchronously (for IndexedDB) */
+    getAsync<T = unknown>(key: string): Promise<T | null>;
+    /** Set a value */
+    set<T = unknown>(key: string, value: T): void;
+    /** Set a value asynchronously */
+    setAsync<T = unknown>(key: string, value: T): Promise<void>;
+    /** Remove a value */
+    remove(key: string): void;
+    /** Remove a value asynchronously */
+    removeAsync(key: string): Promise<void>;
+    /** Clear all values (within namespace) */
+    clear(): void;
+    /** Clear all values asynchronously */
+    clearAsync(): Promise<void>;
+    /** Check if a key exists */
+    has(key: string): boolean;
+    /** Get all keys (within namespace) */
+    keys(): string[];
+    /** Get the current storage backend being used */
+    getCurrentBackend(): StorageBackend;
+    /** Check if storage is available */
+    isAvailable(): boolean;
+}
+/**
+ * Storage adapter configuration.
+ */
+export interface StorageAdapterConfig {
+    /** Namespace prefix for all keys */
+    namespace: string;
+    /** Policy to respect */
+    policy: ITracelessPolicy;
+    /** Preferred backend (will fallback if not available) */
+    preferredBackend?: StorageBackend;
+    /** Whether to encrypt values */
+    encrypt?: boolean;
+    /** Encryption key (required if encrypt is true) */
+    encryptionKey?: string;
+    /** Default TTL for values in seconds */
+    defaultTTL?: number;
+    /** Event handlers */
+    onStorageUnavailable?: (requestedBackend: StorageBackend) => void;
+    onValueExpired?: (key: string) => void;
+    onPolicyViolation?: (operation: string, requestedBackend: StorageBackend) => void;
+}
+/**
+ * Storage item with metadata.
+ */
+export interface StorageItem<T = unknown> {
+    /** The stored value */
+    value: T;
+    /** When the item was created */
+    createdAt: string;
+    /** When the item was last accessed */
+    lastAccessedAt?: string;
+    /** When the item expires (if applicable) */
+    expiresAt?: string;
+    /** Which backend is storing this item */
+    backend: StorageBackend;
+    /** Whether the item is encrypted */
+    encrypted: boolean;
+}
+/**
+ * React hook return type for useTracelessPolicy.
+ */
+export interface UseTracelessPolicyResult extends ITracelessPolicy {
+    /** Whether policy is still loading */
+    isLoading: boolean;
+    /** Error if policy couldn't be loaded */
+    error: Error | null;
+    /** Refresh the policy */
+    refresh: () => Promise<void>;
+    /** Check if a specific operation is allowed */
+    isAllowed: (operation: StorageOperation) => boolean;
+}
+/**
+ * Storage operations that can be checked.
+ */
+export type StorageOperation = 'setCookie' | 'readCookie' | 'setLocalStorage' | 'readLocalStorage' | 'setSessionStorage' | 'readSessionStorage' | 'useIndexedDB' | 'useServiceWorker';
+/**
+ * Props for traceless-aware components.
+ */
+export interface TracelessAwareProps {
+    /** Whether this component can use cookies */
+    cookies?: boolean;
+    /** Whether this component can use localStorage */
+    localStorage?: boolean;
+    /** Storage mode override */
+    storageMode?: 'traceless' | 'ephemeral' | 'persistent' | 'auto';
+}
+/**
+ * Context value for TracelessProvider.
+ */
+export interface TracelessContextValue {
+    /** Current policy */
+    policy: ITracelessPolicy;
+    /** Storage adapter instance */
+    storageAdapter: IStorageAdapter;
+    /** Update user preferences */
+    updatePreferences: (prefs: Partial<UserPrivacyPreferences>) => Promise<void>;
+    /** Check if mode change is allowed */
+    canChangeTo: (mode: TracelessMode) => boolean;
+}
+/**
+ * Flutter storage adapter configuration.
+ */
+export interface FlutterStorageAdapterConfig {
+    /** Namespace for SharedPreferences keys */
+    namespace: string;
+    /** Policy to respect */
+    policy: ITracelessPolicy;
+    /** Use flutter_secure_storage for sensitive data */
+    useSecureStorage: boolean;
+    /** Use Hive for complex data structures */
+    useHive: boolean;
+    /** Hive box name */
+    hiveBoxName?: string;
+}
+/**
+ * Storage scope for different component types.
+ */
+export interface ComponentStorageScope {
+    /** Component type identifier */
+    componentType: string;
+    /** What data this component wants to store */
+    dataCategories: ComponentDataCategory[];
+    /** Required storage for basic functionality */
+    requiredStorage: Partial<StorageCapabilities>;
+    /** Behavior when storage is restricted */
+    restrictedBehavior: RestrictedBehavior;
+}
+/**
+ * Categories of data components might store.
+ */
+export type ComponentDataCategory = 'layout' | 'filters' | 'sorting' | 'selection' | 'view' | 'draft' | 'preferences' | 'history' | 'cache' | 'session' | 'auth';
+/**
+ * How component behaves when storage is restricted.
+ */
+export interface RestrictedBehavior {
+    /** Behavior in traceless mode */
+    traceless: GracefulDegradation;
+    /** Behavior in ephemeral mode */
+    ephemeral: GracefulDegradation;
+    /** Behavior in private mode */
+    private: GracefulDegradation;
+}
+/**
+ * Graceful degradation configuration.
+ */
+export interface GracefulDegradation {
+    /** What features work */
+    availableFeatures: string[];
+    /** What features are disabled */
+    disabledFeatures: string[];
+    /** Warning message to show user */
+    userWarning?: string;
+    /** Default values to use */
+    defaults: Record<string, unknown>;
+}
+/**
+ * NiceDataGrid storage config.
+ */
+export interface DataGridStorageConfig extends TracelessAwareProps {
+    /** What to store */
+    persist?: {
+        columnOrder?: boolean;
+        columnWidths?: boolean;
+        sortState?: boolean;
+        filterState?: boolean;
+        pageSize?: boolean;
+        hiddenColumns?: boolean;
+    };
+    /** Storage key for this grid instance */
+    storageKey?: string;
+}
+/**
+ * NiceKanban storage config.
+ */
+export interface KanbanStorageConfig extends TracelessAwareProps {
+    /** What to store */
+    persist?: {
+        collapsedColumns?: boolean;
+        swimlaneState?: boolean;
+        filterState?: boolean;
+        scrollPosition?: boolean;
+    };
+    /** Storage key for this board instance */
+    storageKey?: string;
+}
+/**
+ * NiceRichTextEditor storage config.
+ */
+export interface RichTextEditorStorageConfig extends TracelessAwareProps {
+    /** Auto-save draft configuration */
+    autosave?: {
+        enabled: boolean;
+        intervalMs: number;
+        maxDrafts: number;
+    };
+    /** Storage key for drafts */
+    draftKey?: string;
+    /** Warning when draft might be lost */
+    showDraftLossWarning?: boolean;
+}
+/**
+ * NiceCalendar storage config.
+ */
+export interface CalendarStorageConfig extends TracelessAwareProps {
+    /** What to store */
+    persist?: {
+        viewMode?: boolean;
+        selectedDate?: boolean;
+        timezone?: boolean;
+        hiddenCalendars?: boolean;
+    };
+    /** Fall back to these defaults when no storage */
+    defaults?: {
+        viewMode?: 'day' | 'week' | 'month' | 'year';
+        showWeekends?: boolean;
+    };
+}
+/**
+ * NiceLoginForm storage config.
+ */
+export interface LoginFormStorageConfig extends TracelessAwareProps {
+    /** Whether "Remember me" option is shown */
+    showRememberMe?: boolean;
+    /** Whether to remember username */
+    rememberUsername?: boolean;
+    /** Cookie expiration for "Remember me" in days */
+    rememberMeDays?: number;
+}
+/**
+ * Consent state for cookie/storage usage.
+ */
+export interface ConsentState {
+    /** Whether any consent has been given */
+    hasConsent: boolean;
+    /** Consent version (for managing consent changes) */
+    consentVersion: string;
+    /** When consent was last updated */
+    consentUpdatedAt: string;
+    /** Granular consent choices */
+    choices: ConsentChoices;
+}
+/**
+ * Granular consent choices.
+ */
+export interface ConsentChoices {
+    /** Strictly necessary (cannot be disabled) */
+    necessary: true;
+    /** Functional cookies */
+    functional?: boolean;
+    /** Analytics cookies */
+    analytics?: boolean;
+    /** Marketing/targeting cookies */
+    marketing?: boolean;
+    /** Third-party cookies */
+    thirdParty?: boolean;
+    /** Custom consent categories */
+    custom?: Record<string, boolean>;
+}
+/**
+ * Consent panel configuration.
+ */
+export interface ConsentPanelConfig {
+    /** Privacy mode determines if panel is shown */
+    policyMode: TracelessMode;
+    /** Available consent categories */
+    categories: ConsentCategory[];
+    /** Privacy policy URL */
+    privacyPolicyUrl?: string;
+    /** Cookie policy URL */
+    cookiePolicyUrl?: string;
+    /** Position of the banner */
+    position?: 'top' | 'bottom' | 'center';
+    /** Theme */
+    theme?: 'light' | 'dark' | 'auto';
+    /** Text customization */
+    text?: ConsentPanelText;
+}
+/**
+ * Consent category definition.
+ */
+export interface ConsentCategory {
+    /** Category identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description */
+    description: string;
+    /** Whether category is required */
+    required: boolean;
+    /** Default state if not required */
+    defaultEnabled?: boolean;
+    /** Cookies/storage used by this category */
+    items?: ConsentItem[];
+}
+/**
+ * Individual consent item (cookie or storage key).
+ */
+export interface ConsentItem {
+    /** Item name */
+    name: string;
+    /** Provider/domain */
+    provider: string;
+    /** Purpose */
+    purpose: string;
+    /** Expiry */
+    expiry?: string;
+    /** Type */
+    type: 'cookie' | 'localStorage' | 'sessionStorage' | 'indexedDB';
+}
+/**
+ * Text customization for consent panel.
+ */
+export interface ConsentPanelText {
+    /** Banner title */
+    title?: string;
+    /** Banner description */
+    description?: string;
+    /** Accept all button */
+    acceptAll?: string;
+    /** Reject all button */
+    rejectAll?: string;
+    /** Customize button */
+    customize?: string;
+    /** Save preferences button */
+    savePreferences?: string;
+}
+/**
+ * Privacy policy change audit entry.
+ */
+export interface PolicyAuditEntry {
+    /** Entry ID */
+    id: string;
+    /** Timestamp */
+    timestamp: string;
+    /** Who made the change */
+    changedBy: string;
+    /** What changed */
+    changeType: PolicyChangeType;
+    /** Previous mode */
+    previousMode?: TracelessMode;
+    /** New mode */
+    newMode?: TracelessMode;
+    /** Previous capabilities */
+    previousCapabilities?: Partial<StorageCapabilities>;
+    /** New capabilities */
+    newCapabilities?: Partial<StorageCapabilities>;
+    /** Reason for change */
+    reason?: string;
+    /** IP address */
+    ipAddress?: string;
+    /** User agent */
+    userAgent?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Types of policy changes.
+ */
+export type PolicyChangeType = 'mode_change' | 'capability_change' | 'user_lockdown' | 'admin_override' | 'tenant_policy_update' | 'instance_ceiling_update' | 'group_policy_update';
+/**
+ * Compliance report for Traceless mode.
+ */
+export interface TracelessComplianceReport {
+    /** Report ID */
+    reportId: string;
+    /** Generated timestamp */
+    generatedAt: string;
+    /** Instance identifier */
+    instanceId: string;
+    /** Tenant identifier */
+    tenantId?: string;
+    /** Current mode */
+    mode: TracelessMode;
+    /** Storage capabilities summary */
+    storageCapabilities: StorageCapabilities;
+    /** Cookie count (should be 0 in traceless) */
+    cookieCount: number;
+    /** localStorage keys count */
+    localStorageKeys: number;
+    /** sessionStorage keys count */
+    sessionStorageKeys: number;
+    /** Whether consent banner is required */
+    consentBannerRequired: boolean;
+    /** Compliance statements */
+    complianceStatements: ComplianceStatement[];
+    /** Legal disclaimer */
+    legalDisclaimer: string;
+}
+/**
+ * Compliance statement for regulations.
+ */
+export interface ComplianceStatement {
+    /** Regulation name */
+    regulation: string;
+    /** Relevant article/section */
+    article?: string;
+    /** Compliance status */
+    status: 'compliant' | 'exempt' | 'requires_review';
+    /** Explanation */
+    explanation: string;
+}
+/**
+ * Privacy API endpoint definitions.
+ */
+export interface PrivacyAPI {
+    /** Get effective policy */
+    getPolicy: () => Promise<ITracelessPolicy>;
+    /** Update user preferences */
+    updatePolicy: (prefs: Partial<UserPrivacyPreferences>) => Promise<ITracelessPolicy>;
+    /** Get capabilities for current mode */
+    getCapabilities: () => Promise<StorageCapabilities>;
+    /** Get audit log */
+    getAuditLog: (params: AuditLogParams) => Promise<PolicyAuditEntry[]>;
+    /** Generate compliance report */
+    generateComplianceReport: () => Promise<TracelessComplianceReport>;
+}
+/**
+ * Audit log query parameters.
+ */
+export interface AuditLogParams {
+    /** Start date */
+    from?: string;
+    /** End date */
+    to?: string;
+    /** Filter by user */
+    userId?: string;
+    /** Filter by change type */
+    changeType?: PolicyChangeType;
+    /** Page number */
+    page?: number;
+    /** Page size */
+    pageSize?: number;
+}
+/**
+ * Storage scanner configuration for CI/CD.
+ */
+export interface StorageScannerConfig {
+    /** Base URL to scan */
+    baseUrl: string;
+    /** Pages to visit */
+    pages: string[];
+    /** Expected mode */
+    expectedMode: TracelessMode;
+    /** Whether to fail on any cookie */
+    failOnCookie: boolean;
+    /** Whether to fail on any localStorage */
+    failOnLocalStorage: boolean;
+    /** Whether to fail on any sessionStorage */
+    failOnSessionStorage: boolean;
+    /** Timeout per page in ms */
+    pageTimeout: number;
+    /** Output format */
+    outputFormat: 'json' | 'junit' | 'console';
+}
+/**
+ * Storage scan result.
+ */
+export interface StorageScanResult {
+    /** Scan timestamp */
+    timestamp: string;
+    /** Base URL scanned */
+    baseUrl: string;
+    /** Pages scanned */
+    pagesScanned: number;
+    /** Overall pass/fail */
+    passed: boolean;
+    /** Violations found */
+    violations: StorageViolation[];
+    /** Summary statistics */
+    summary: StorageScanSummary;
+}
+/**
+ * A storage violation found during scan.
+ */
+export interface StorageViolation {
+    /** Page URL where violation occurred */
+    pageUrl: string;
+    /** Type of violation */
+    type: 'cookie' | 'localStorage' | 'sessionStorage' | 'indexedDB';
+    /** Key name */
+    key: string;
+    /** Value (may be truncated) */
+    value?: string;
+    /** Likely source/framework */
+    suspectedSource?: string;
+    /** Severity */
+    severity: 'critical' | 'high' | 'medium' | 'low';
+}
+/**
+ * Scan summary statistics.
+ */
+export interface StorageScanSummary {
+    /** Total cookies found */
+    totalCookies: number;
+    /** Total localStorage keys */
+    totalLocalStorageKeys: number;
+    /** Total sessionStorage keys */
+    totalSessionStorageKeys: number;
+    /** Total IndexedDB databases */
+    totalIndexedDBDatabases: number;
+    /** Total violations */
+    totalViolations: number;
+    /** Violations by severity */
+    violationsBySeverity: Record<string, number>;
+}
+/**
+ * Default traceless policy - maximum privacy.
+ */
+export declare const DEFAULT_TRACELESS_POLICY: ITracelessPolicy;
+/**
+ * Default full policy - all storage allowed.
+ */
+export declare const DEFAULT_FULL_POLICY: ITracelessPolicy;
+/**
+ * Mode to capabilities mapping.
+ */
+export declare const MODE_CAPABILITIES: Record<TracelessMode, StorageCapabilities>;
+//# sourceMappingURL=traceless.d.ts.map