spck 0.3.1

package/dist/config/__tests__/credentials.test.js

@@ -0,0 +1,360 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+/**
+ * Unit tests for credentials management
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import { loadCredentials, saveCredentials, loadConnectionSettings, saveConnectionSettings, isServerTokenExpired, getCredentialsPath, getConnectionSettingsPath, getGlobalConfigPath, loadGlobalConfig, saveGlobalConfig, clearCredentials, clearConnectionSettings, } from '../credentials.js';
+// Mock modules
+vi.mock('fs');
+vi.mock('os');
+const mockFs = fs;
+const mockOs = os;
+describe('credentials', () => {
+    const mockHomedir = '/mock/home';
+    const mockCwd = '/mock/project';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockOs.homedir.mockReturnValue(mockHomedir);
+        vi.spyOn(process, 'cwd').mockReturnValue(mockCwd);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('getCredentialsPath()', () => {
+        it('should return path in user home directory', () => {
+            const path = getCredentialsPath();
+            expect(path).toBe(`${mockHomedir}/.spck-editor/.credentials.json`);
+        });
+    });
+    describe('getConnectionSettingsPath()', () => {
+        it('should return path in .spck-editor/config subdirectory', () => {
+            const path = getConnectionSettingsPath();
+            expect(path).toBe(`${mockCwd}/.spck-editor/config/connection-settings.json`);
+        });
+    });
+    describe('loadCredentials()', () => {
+        it('should return null if file does not exist', () => {
+            mockFs.existsSync.mockReturnValue(false);
+            const result = loadCredentials();
+            expect(result).toBeNull();
+        });
+        it('should load and return valid stored credentials', () => {
+            const mockCredentials = {
+                refreshToken: 'mock-refresh-token',
+                userId: 'user-123',
+            };
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue(JSON.stringify(mockCredentials));
+            const result = loadCredentials();
+            expect(result).toEqual(mockCredentials);
+        });
+        it('should throw CORRUPTED error for invalid JSON', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue('invalid json{');
+            expect(() => loadCredentials()).toThrow('Credentials file is corrupted');
+            expect(() => {
+                try {
+                    loadCredentials();
+                }
+                catch (error) {
+                    expect(error.code).toBe('CORRUPTED');
+                    throw error;
+                }
+            }).toThrow();
+        });
+        it('should throw CORRUPTED error for missing refreshToken', () => {
+            const invalidCredentials = {
+                userId: 'user-123',
+            };
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue(JSON.stringify(invalidCredentials));
+            expect(() => {
+                try {
+                    loadCredentials();
+                }
+                catch (error) {
+                    expect(error.code).toBe('CORRUPTED');
+                    throw error;
+                }
+            }).toThrow();
+        });
+        it('should throw CORRUPTED error for missing userId', () => {
+            const invalidCredentials = {
+                refreshToken: 'mock-refresh-token',
+            };
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue(JSON.stringify(invalidCredentials));
+            expect(() => {
+                try {
+                    loadCredentials();
+                }
+                catch (error) {
+                    expect(error.code).toBe('CORRUPTED');
+                    throw error;
+                }
+            }).toThrow();
+        });
+        it('should only return refreshToken and userId even if file has extra fields', () => {
+            const storedWithExtra = {
+                refreshToken: 'mock-refresh-token',
+                userId: 'user-123',
+                firebaseToken: 'old-token',
+                firebaseTokenExpiry: Date.now(),
+            };
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue(JSON.stringify(storedWithExtra));
+            const result = loadCredentials();
+            // Should only return the stored credentials fields
+            expect(result).toEqual({
+                refreshToken: 'mock-refresh-token',
+                userId: 'user-123',
+            });
+        });
+    });
+    describe('saveCredentials()', () => {
+        const mockCredentials = {
+            refreshToken: 'mock-refresh-token',
+            userId: 'user-123',
+        };
+        it('should create directory if it does not exist', () => {
+            mockFs.existsSync.mockReturnValue(false);
+            mockFs.mkdirSync.mockReturnValue(undefined);
+            mockFs.writeFileSync.mockReturnValue(undefined);
+            saveCredentials(mockCredentials);
+            expect(mockFs.mkdirSync).toHaveBeenCalledWith(`${mockHomedir}/.spck-editor`, { recursive: true, mode: 0o700 });
+        });
+        it('should write only refreshToken and userId with correct permissions', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.writeFileSync.mockReturnValue(undefined);
+            saveCredentials(mockCredentials);
+            // Should only persist refreshToken + userId
+            const expectedStored = {
+                refreshToken: 'mock-refresh-token',
+                userId: 'user-123',
+            };
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith(`${mockHomedir}/.spck-editor/.credentials.json`, JSON.stringify(expectedStored, null, 2), { encoding: 'utf8', mode: 0o600 });
+        });
+        it('should throw error with operation context on write failure', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            const mockError = new Error('ENOSPC: no space left');
+            mockError.code = 'ENOSPC';
+            mockFs.writeFileSync.mockImplementation(() => {
+                throw mockError;
+            });
+            expect(() => {
+                try {
+                    saveCredentials(mockCredentials);
+                }
+                catch (error) {
+                    expect(error.operation).toBe('save credentials');
+                    throw error;
+                }
+            }).toThrow();
+        });
+    });
+    describe('loadConnectionSettings()', () => {
+        it('should return null if file does not exist', () => {
+            mockFs.existsSync.mockReturnValue(false);
+            const result = loadConnectionSettings();
+            expect(result).toBeNull();
+        });
+        it('should load and return valid connection settings', () => {
+            const mockSettings = {
+                serverToken: 'server-token',
+                serverTokenExpiry: Date.now() + 3600000,
+                clientId: 'client-123',
+                secret: 'secret-abc',
+                userId: 'user-123',
+                connectedAt: Date.now(),
+            };
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue(JSON.stringify(mockSettings));
+            const result = loadConnectionSettings();
+            expect(result).toEqual(mockSettings);
+        });
+        it('should throw CORRUPTED error for invalid JSON', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue('not valid json');
+            expect(() => {
+                try {
+                    loadConnectionSettings();
+                }
+                catch (error) {
+                    expect(error.code).toBe('CORRUPTED');
+                    throw error;
+                }
+            }).toThrow();
+        });
+        it('should throw CORRUPTED error for missing required fields', () => {
+            const invalidSettings = {
+                serverToken: 'token',
+                // missing clientId and secret
+            };
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue(JSON.stringify(invalidSettings));
+            expect(() => {
+                try {
+                    loadConnectionSettings();
+                }
+                catch (error) {
+                    expect(error.code).toBe('CORRUPTED');
+                    throw error;
+                }
+            }).toThrow();
+        });
+    });
+    describe('saveConnectionSettings()', () => {
+        const mockSettings = {
+            serverToken: 'server-token',
+            serverTokenExpiry: Date.now() + 3600000,
+            clientId: 'client-123',
+            secret: 'secret-abc',
+            userId: 'user-123',
+            connectedAt: Date.now(),
+        };
+        it('should create directory if it does not exist', () => {
+            mockFs.existsSync.mockReturnValue(false);
+            mockFs.mkdirSync.mockReturnValue(undefined);
+            mockFs.writeFileSync.mockReturnValue(undefined);
+            saveConnectionSettings(mockSettings);
+            expect(mockFs.mkdirSync).toHaveBeenCalledWith(`${mockCwd}/.spck-editor/config`, { recursive: true, mode: 0o700 });
+        });
+        it('should write settings file with restricted permissions', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.writeFileSync.mockReturnValue(undefined);
+            saveConnectionSettings(mockSettings);
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith(`${mockCwd}/.spck-editor/config/connection-settings.json`, JSON.stringify(mockSettings, null, 2), { encoding: 'utf8', mode: 0o600 });
+        });
+        it('should throw error with operation context on write failure', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            const mockError = new Error('EACCES: permission denied');
+            mockError.code = 'EACCES';
+            mockFs.writeFileSync.mockImplementation(() => {
+                throw mockError;
+            });
+            expect(() => {
+                try {
+                    saveConnectionSettings(mockSettings);
+                }
+                catch (error) {
+                    expect(error.operation).toBe('save connection settings');
+                    throw error;
+                }
+            }).toThrow();
+        });
+    });
+    describe('isServerTokenExpired()', () => {
+        it('should return true if settings is null', () => {
+            expect(isServerTokenExpired(null)).toBe(true);
+        });
+        it('should return true if serverTokenExpiry is missing', () => {
+            expect(isServerTokenExpired({ serverToken: 'token' })).toBe(true);
+        });
+        it('should return true if token has expired', () => {
+            const expiredSettings = {
+                serverToken: 'token',
+                serverTokenExpiry: Date.now() - 1000,
+            };
+            expect(isServerTokenExpired(expiredSettings)).toBe(true);
+        });
+        it('should return false if token is still valid', () => {
+            const validSettings = {
+                serverToken: 'token',
+                serverTokenExpiry: Date.now() + 3600000,
+            };
+            expect(isServerTokenExpired(validSettings)).toBe(false);
+        });
+    });
+    describe('clearCredentials()', () => {
+        it('should delete credentials file if it exists', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.unlinkSync.mockReturnValue(undefined);
+            clearCredentials();
+            expect(mockFs.unlinkSync).toHaveBeenCalledWith(`${mockHomedir}/.spck-editor/.credentials.json`);
+        });
+        it('should do nothing if file does not exist', () => {
+            mockFs.existsSync.mockReturnValue(false);
+            clearCredentials();
+            expect(mockFs.unlinkSync).not.toHaveBeenCalled();
+        });
+    });
+    describe('clearConnectionSettings()', () => {
+        it('should delete settings file if it exists', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.unlinkSync.mockReturnValue(undefined);
+            clearConnectionSettings();
+            expect(mockFs.unlinkSync).toHaveBeenCalledWith(`${mockCwd}/.spck-editor/config/connection-settings.json`);
+        });
+        it('should do nothing if file does not exist', () => {
+            mockFs.existsSync.mockReturnValue(false);
+            clearConnectionSettings();
+            expect(mockFs.unlinkSync).not.toHaveBeenCalled();
+        });
+    });
+    describe('getGlobalConfigPath()', () => {
+        it('should return path in user home directory', () => {
+            const configPath = getGlobalConfigPath();
+            expect(configPath).toBe(`${mockHomedir}/.spck-editor/global.config`);
+        });
+    });
+    describe('loadGlobalConfig()', () => {
+        it('should return default config if file does not exist', () => {
+            mockFs.existsSync.mockReturnValue(false);
+            const result = loadGlobalConfig();
+            expect(result).toEqual({ knownDeviceIds: [] });
+        });
+        it('should load and return valid global config', () => {
+            const mockConfig = {
+                knownDeviceIds: ['device-aaa', 'device-bbb'],
+            };
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue(JSON.stringify(mockConfig));
+            const result = loadGlobalConfig();
+            expect(result).toEqual(mockConfig);
+        });
+        it('should return default config if JSON is invalid', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue('not valid json{');
+            const result = loadGlobalConfig();
+            expect(result).toEqual({ knownDeviceIds: [] });
+        });
+        it('should return default config if knownDeviceIds is not an array', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue(JSON.stringify({ knownDeviceIds: 'bad' }));
+            const result = loadGlobalConfig();
+            expect(result).toEqual({ knownDeviceIds: [] });
+        });
+        it('should return empty knownDeviceIds if field is missing', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue(JSON.stringify({}));
+            const result = loadGlobalConfig();
+            expect(result).toEqual({ knownDeviceIds: [] });
+        });
+    });
+    describe('saveGlobalConfig()', () => {
+        const mockConfig = {
+            knownDeviceIds: ['device-aaa', 'device-bbb'],
+        };
+        it('should create directory if it does not exist', () => {
+            mockFs.existsSync.mockReturnValue(false);
+            mockFs.mkdirSync.mockReturnValue(undefined);
+            mockFs.writeFileSync.mockReturnValue(undefined);
+            saveGlobalConfig(mockConfig);
+            expect(mockFs.mkdirSync).toHaveBeenCalledWith(`${mockHomedir}/.spck-editor`, { recursive: true, mode: 0o700 });
+        });
+        it('should write config file with correct content and restricted permissions', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.writeFileSync.mockReturnValue(undefined);
+            saveGlobalConfig(mockConfig);
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith(`${mockHomedir}/.spck-editor/global.config`, JSON.stringify(mockConfig, null, 2), { encoding: 'utf8', mode: 0o600 });
+        });
+        it('should not create directory if it already exists', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.writeFileSync.mockReturnValue(undefined);
+            saveGlobalConfig(mockConfig);
+            expect(mockFs.mkdirSync).not.toHaveBeenCalled();
+        });
+    });
+});
+//# sourceMappingURL=credentials.test.js.map

package/dist/config/config.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Configuration management for spck-cli server
+ */
+import { ServerConfig } from '../types.js';
+/**
+ * Load server configuration from file
+ * If config file doesn't exist, runs setup wizard
+ * @throws {ConfigNotFoundError} if file doesn't exist
+ * @throws {Error} with code 'CORRUPTED' if file is corrupted
+ */
+export declare function loadConfig(configPath?: string): ServerConfig;
+/**
+ * Custom error for missing configuration
+ */
+export declare class ConfigNotFoundError extends Error {
+    configPath: string;
+    constructor(configPath: string);
+}
+/**
+ * Save server configuration to file
+ * @throws {Error} with code 'EACCES' for permission errors
+ * @throws {Error} with code 'ENOSPC' for disk full errors
+ */
+export declare function saveConfig(config: ServerConfig, configPath?: string): void;
+/**
+ * Create default configuration template
+ */
+export declare function createDefaultConfig(overrides?: Partial<ServerConfig>): ServerConfig;
+/**
+ * Parse file size string to bytes
+ */
+export declare function parseFileSize(sizeStr: string): number;
+//# sourceMappingURL=config.d.ts.map

package/dist/config/config.js

@@ -0,0 +1,185 @@
+/**
+ * Configuration management for spck-cli server
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getProjectFilePath } from '../utils/project-dir.js';
+import { t } from '../i18n/index.js';
+const DEFAULT_CONFIG_FILENAME = 'spck-cli.config.json';
+/**
+ * Load server configuration from file
+ * If config file doesn't exist, runs setup wizard
+ * @throws {ConfigNotFoundError} if file doesn't exist
+ * @throws {Error} with code 'CORRUPTED' if file is corrupted
+ */
+export function loadConfig(configPath) {
+    // If a custom config path is provided, use it as-is
+    // Otherwise use the default location in the project directory
+    const fullPath = configPath
+        ? path.resolve(process.cwd(), configPath)
+        : getProjectFilePath(process.cwd(), DEFAULT_CONFIG_FILENAME);
+    if (!fs.existsSync(fullPath)) {
+        console.log('\n' + t('config.fileNotFound', { path: fullPath }));
+        console.log(t('config.fileNotFoundHint') + '\n');
+        // Signal to caller that setup is needed
+        throw new ConfigNotFoundError(fullPath);
+    }
+    try {
+        const configData = fs.readFileSync(fullPath, 'utf8');
+        const config = JSON.parse(configData);
+        // Validate required fields
+        validateConfig(config);
+        // Backward-compatibility: populate missing optional sections and re-save
+        let needsSave = false;
+        if (!config.browserProxy) {
+            config.browserProxy = { enabled: true };
+            needsSave = true;
+        }
+        if (needsSave) {
+            try {
+                saveConfig(config, configPath);
+            }
+            catch { /* best-effort */ }
+        }
+        return config;
+    }
+    catch (error) {
+        // JSON parse error or validation error
+        if (error instanceof SyntaxError || (error.message && error.message.includes('Invalid'))) {
+            console.warn('⚠️  ' + t('config.fileCorrupted', { path: fullPath }));
+            console.warn('   ' + t('config.fileCorruptedHint') + '\n');
+            const corruptedError = new Error('Configuration file is corrupted');
+            corruptedError.code = 'CORRUPTED';
+            corruptedError.path = fullPath;
+            corruptedError.originalError = error;
+            throw corruptedError;
+        }
+        // Other errors (permission, etc.)
+        throw error;
+    }
+}
+/**
+ * Custom error for missing configuration
+ */
+export class ConfigNotFoundError extends Error {
+    constructor(configPath) {
+        super(`Configuration file not found: ${configPath}`);
+        this.configPath = configPath;
+        this.name = 'ConfigNotFoundError';
+    }
+}
+/**
+ * Save server configuration to file
+ * @throws {Error} with code 'EACCES' for permission errors
+ * @throws {Error} with code 'ENOSPC' for disk full errors
+ */
+export function saveConfig(config, configPath) {
+    // If a custom config path is provided, use it as-is
+    // Otherwise use the default location in the project directory
+    const fullPath = configPath
+        ? path.resolve(process.cwd(), configPath)
+        : getProjectFilePath(process.cwd(), DEFAULT_CONFIG_FILENAME);
+    try {
+        // Ensure directory exists
+        const dir = path.dirname(fullPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // Validate before saving
+        validateConfig(config);
+        // Write config file
+        fs.writeFileSync(fullPath, JSON.stringify(config, null, 2), 'utf8');
+    }
+    catch (error) {
+        // Add context to error
+        error.path = error.path || fullPath;
+        error.operation = 'save config';
+        throw error;
+    }
+}
+/**
+ * Validate configuration
+ */
+function validateConfig(config) {
+    if (!config.version || config.version !== 1) {
+        throw new Error('Invalid config version. Expected version 1.');
+    }
+    if (!config.root || typeof config.root !== 'string') {
+        throw new Error('Invalid or missing root directory in configuration.');
+    }
+    if (!fs.existsSync(config.root)) {
+        throw new Error(`Root directory does not exist: ${config.root}`);
+    }
+    if (!config.terminal || typeof config.terminal !== 'object') {
+        throw new Error('Invalid or missing terminal configuration.');
+    }
+    if (typeof config.terminal.enabled !== 'boolean') {
+        throw new Error('Terminal enabled must be a boolean.');
+    }
+    if (!config.security || typeof config.security !== 'object') {
+        throw new Error('Invalid or missing security configuration.');
+    }
+    if (!config.filesystem || typeof config.filesystem !== 'object') {
+        throw new Error('Invalid or missing filesystem configuration.');
+    }
+}
+/**
+ * Get current directory name for default server name
+ */
+function getDefaultServerName() {
+    const cwd = process.cwd();
+    return path.basename(cwd);
+}
+/**
+ * Create default configuration template
+ */
+export function createDefaultConfig(overrides = {}) {
+    return {
+        version: 1,
+        root: process.cwd(),
+        name: getDefaultServerName(),
+        terminal: {
+            enabled: true,
+            maxBufferedLines: 5000,
+            maxTerminals: 10,
+        },
+        security: {
+            userAuthenticationEnabled: false,
+        },
+        filesystem: {
+            maxFileSize: '10MB',
+            watchIgnorePatterns: [
+                '**/.git/**',
+                '**/.spck-editor/**',
+                '**/node_modules/**',
+                '**/*.log',
+                '**/.DS_Store',
+                '**/dist/**',
+                '**/build/**'
+            ],
+        },
+        browserProxy: {
+            enabled: true,
+        },
+        ...overrides,
+    };
+}
+/**
+ * Parse file size string to bytes
+ */
+export function parseFileSize(sizeStr) {
+    const match = sizeStr.match(/^(\d+(?:\.\d+)?)\s*(B|KB|MB|GB)?$/i);
+    if (!match) {
+        throw new Error(`Invalid file size format: ${sizeStr}`);
+    }
+    const value = parseFloat(match[1]);
+    const unit = (match[2] || 'B').toUpperCase();
+    const multipliers = {
+        B: 1,
+        KB: 1024,
+        MB: 1024 * 1024,
+        GB: 1024 * 1024 * 1024,
+    };
+    return value * multipliers[unit];
+}
+//# sourceMappingURL=config.js.map

package/dist/config/credentials.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Firebase credentials management
+ * Handles user-level credential storage in ~/.spck-editor/.credentials.json
+ */
+import { StoredCredentials, GlobalConfig } from '../types.js';
+/**
+ * Get the user-level credentials directory
+ */
+export declare function getCredentialsDir(): string;
+/**
+ * Get the credentials file path
+ */
+export declare function getCredentialsPath(): string;
+/**
+ * Get the global config file path
+ */
+export declare function getGlobalConfigPath(): string;
+/**
+ * Load global config from user-level storage
+ */
+export declare function loadGlobalConfig(): GlobalConfig;
+/**
+ * Save global config to user-level storage
+ */
+export declare function saveGlobalConfig(config: GlobalConfig): void;
+/**
+ * Get the connection settings file path (project-level)
+ * This uses the symlinked project directory
+ */
+export declare function getConnectionSettingsPath(): string;
+/**
+ * Load stored credentials from user-level storage
+ * Returns only refreshToken + userId; firebaseToken is generated on demand
+ * @throws {Error} with code 'CORRUPTED' if file is corrupted
+ */
+export declare function loadCredentials(): StoredCredentials | null;
+/**
+ * Save stored credentials to user-level storage
+ * Only persists refreshToken + userId (not firebaseToken or expiry)
+ * @throws {Error} with code 'EACCES' for permission errors
+ * @throws {Error} with code 'ENOSPC' for disk full errors
+ */
+export declare function saveCredentials(credentials: StoredCredentials): void;
+/**
+ * Clear credentials (logout)
+ */
+export declare function clearCredentials(): void;
+/**
+ * Load connection settings from project-level storage
+ * @throws {Error} with code 'CORRUPTED' if file is corrupted
+ */
+export declare function loadConnectionSettings(): any | null;
+/**
+ * Save connection settings to project-level storage
+ * @throws {Error} with code 'EACCES' for permission errors
+ * @throws {Error} with code 'ENOSPC' for disk full errors
+ */
+export declare function saveConnectionSettings(settings: any): void;
+/**
+ * Clear connection settings
+ */
+export declare function clearConnectionSettings(): void;
+/**
+ * Load saved proxy server preference from user-level credentials
+ */
+export declare function loadServerPreference(): string | null;
+/**
+ * Save proxy server preference to user-level credentials
+ */
+export declare function saveServerPreference(proxyServerUrl: string): void;
+/**
+ * Check if server JWT is expired
+ */
+export declare function isServerTokenExpired(settings: any): boolean;
+//# sourceMappingURL=credentials.d.ts.map