langctl 0.1.1 → 0.2.0

package/dist/commands/import.js

@@ -0,0 +1,150 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { isAuthenticated } from '../auth.js';
+import { getApiClient } from '../api.js';
+import { config } from '../config.js';
+/**
+ * Parse translation file based on extension
+ */
+function parseTranslationFile(filePath) {
+    const content = readFileSync(filePath, 'utf-8');
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    if (ext === 'json') {
+        const parsed = JSON.parse(content);
+        // Check if it's nested JSON and flatten it
+        if (isNestedObject(parsed)) {
+            return flattenObject(parsed);
+        }
+        return parsed;
+    }
+    throw new Error(`Unsupported file format: .${ext}. Only JSON files are currently supported.`);
+}
+/**
+ * Check if object has nested objects
+ */
+function isNestedObject(obj) {
+    return Object.values(obj).some(value => typeof value === 'object' && value !== null && !Array.isArray(value));
+}
+/**
+ * Flatten nested object to dot-notation keys
+ */
+function flattenObject(obj, prefix = '') {
+    const result = {};
+    Object.entries(obj).forEach(([key, value]) => {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === 'string') {
+            result[fullKey] = value;
+        }
+        else if (typeof value === 'object' && value !== null) {
+            Object.assign(result, flattenObject(value, fullKey));
+        }
+    });
+    return result;
+}
+/**
+ * Import translations command
+ */
+export async function importCommand(projectSlug, filePath, options) {
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const orgId = config.get('organizationId');
+    if (!orgId) {
+        console.log(chalk.red('✗ Organization ID not found. Please run "langctl auth <api-key>" again.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const spinner = ora('Loading file...').start();
+    try {
+        // Resolve file path
+        const resolvedPath = resolve(filePath);
+        // Parse translation file
+        spinner.text = 'Parsing translation file...';
+        const translations = parseTranslationFile(resolvedPath);
+        const keyCount = Object.keys(translations).length;
+        if (keyCount === 0) {
+            spinner.warn(chalk.yellow('No translations found in file'));
+            return;
+        }
+        spinner.text = 'Fetching project...';
+        // Get project by slug
+        const api = getApiClient();
+        const project = await api.get(`/orgs/${orgId}/projects/by-slug/${projectSlug}`);
+        // Validate language
+        if (!project.languages.includes(options.language)) {
+            spinner.fail(chalk.red(`Language "${options.language}" not found in project`));
+            console.log(chalk.yellow(`Available languages: ${project.languages.join(', ')}\n`));
+            return;
+        }
+        spinner.text = `Importing ${keyCount} translations...`;
+        // Push translations via REST API
+        const body = {
+            language: options.language,
+            translations,
+            // Keep import safe by default; only overwrite when explicitly requested.
+            overwriteExisting: options.overwrite === true
+        };
+        if (options.module)
+            body.module = options.module;
+        const data = await api.post(`/orgs/${orgId}/projects/${project.id}/import`, body);
+        let publishedCount = 0;
+        if (options.publish) {
+            spinner.text = 'Publishing imported keys...';
+            const keyNames = new Set(Object.keys(translations));
+            const keyIds = [];
+            let page = 1;
+            const pageSize = 100;
+            while (true) {
+                const keysPage = await api.get(`/orgs/${orgId}/projects/${project.id}/keys`, {
+                    page: String(page),
+                    pageSize: String(pageSize)
+                });
+                for (const key of (keysPage.data || [])) {
+                    if (keyNames.has(key.key)) {
+                        keyIds.push(key.id);
+                    }
+                }
+                const totalPages = keysPage.pagination?.totalPages || 1;
+                if (page >= totalPages)
+                    break;
+                page += 1;
+            }
+            if (keyIds.length > 0) {
+                await api.post(`/orgs/${orgId}/projects/${project.id}/keys/bulk-publish`, {
+                    keyIds,
+                    published: true
+                });
+                publishedCount = keyIds.length;
+            }
+        }
+        spinner.succeed(chalk.green('Import completed successfully'));
+        console.log(chalk.green(`\n✓ Created: ${data.created}`));
+        console.log(chalk.blue(`✓ Updated: ${data.updated}`));
+        console.log(chalk.yellow(`⊘ Skipped: ${data.skipped}`));
+        if (options.publish) {
+            console.log(chalk.magenta(`✓ Published: ${publishedCount}`));
+        }
+        console.log(chalk.white(`  Total: ${data.total}`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to import translations'));
+        if (error.code === 'ENOENT') {
+            console.error(chalk.red(`Error: File not found: ${filePath}\n`));
+            process.exitCode = 1;
+        }
+        else if (error instanceof SyntaxError) {
+            console.error(chalk.red(`Error: Invalid JSON file\n`));
+            process.exitCode = 1;
+        }
+        else {
+            console.error(chalk.red(`Error: ${error.message}\n`));
+            process.exitCode = 1;
+        }
+    }
+}
+//# sourceMappingURL=import.js.map

package/dist/commands/init.js

@@ -3,7 +3,6 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { config } from '../config.js';
 import { authenticate } from '../auth.js';
-import { initializeSupabase } from '../supabase.js';
 import { showLogo } from '../utils/banner.js';
 export async function initCommand() {
     // Show logo
@@ -25,15 +24,6 @@ export async function initCommand() {
             return;
         }
     }
-    // Initialize Supabase client (with hardcoded credentials - user doesn't need to know)
-    try {
-        initializeSupabase();
-    }
-    catch (error) {
-        console.error(chalk.red('✗ Failed to connect to Langctl servers'));
-        console.error(chalk.red('Please check your internet connection and try again.\n'));
-        return;
-    }
     // Ask for API key
     const { apiKey } = await inquirer.prompt([
         {

package/dist/commands/keys.d.ts

@@ -0,0 +1,25 @@
+/**
+ * List translation keys
+ */
+export declare function listKeysCommand(projectSlug: string, options: any): Promise<void>;
+/**
+ * Get single key
+ */
+export declare function getKeyCommand(projectSlug: string, keyName: string): Promise<void>;
+/**
+ * Create translation key
+ */
+export declare function createKeyCommand(projectSlug: string, keyName: string, options: any): Promise<void>;
+/**
+ * Delete translation key
+ */
+export declare function deleteKeyCommand(projectSlug: string, keyName: string): Promise<void>;
+/**
+ * Update single translation
+ */
+export declare function translateKeyCommand(projectSlug: string, keyName: string, options: any): Promise<void>;
+/**
+ * Publish/unpublish keys
+ */
+export declare function publishKeysCommand(projectSlug: string, keys: string[], options: any): Promise<void>;
+//# sourceMappingURL=keys.d.ts.map

package/dist/commands/keys.js

@@ -0,0 +1,294 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { isAuthenticated } from '../auth.js';
+import { getApiClient } from '../api.js';
+import { config } from '../config.js';
+/**
+ * Resolve a project slug to a full project object
+ */
+async function resolveProject(orgId, slug) {
+    const api = getApiClient();
+    return api.get(`/orgs/${orgId}/projects/by-slug/${slug}`);
+}
+/**
+ * Find a key by exact name within a project (search + exact match)
+ */
+async function findKeyByName(orgId, projectId, keyName) {
+    const api = getApiClient();
+    const result = await api.get(`/orgs/${orgId}/projects/${projectId}/keys`, {
+        search: keyName,
+        pageSize: '100'
+    });
+    const key = result.data?.find((k) => k.key === keyName);
+    return key || null;
+}
+/**
+ * List translation keys
+ */
+export async function listKeysCommand(projectSlug, options) {
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const orgId = config.get('organizationId');
+    if (!orgId) {
+        console.log(chalk.red('✗ Organization ID not found. Please run "langctl auth <api-key>" again.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const spinner = ora('Fetching keys...').start();
+    try {
+        const project = await resolveProject(orgId, projectSlug);
+        const limit = Math.max(1, parseInt(options.limit || '100', 10) || 100);
+        const offset = Math.max(0, parseInt(options.offset || '0', 10) || 0);
+        const skipWithinPage = offset % limit;
+        const page = Math.floor(offset / limit) + 1;
+        const pageSize = Math.min(100, limit + skipWithinPage);
+        const api = getApiClient();
+        const params = {
+            page: String(page),
+            pageSize: String(pageSize)
+        };
+        if (options.module)
+            params.module = options.module;
+        if (options.search)
+            params.search = options.search;
+        if (options.published)
+            params.published = 'true';
+        const result = await api.get(`/orgs/${orgId}/projects/${project.id}/keys`, params);
+        spinner.stop();
+        let keys = result.data || [];
+        if (skipWithinPage > 0) {
+            keys = keys.slice(skipWithinPage);
+        }
+        keys = keys.slice(0, limit);
+        const total = result.pagination?.total;
+        if (!keys || keys.length === 0) {
+            console.log(chalk.yellow('\nNo keys found\n'));
+            return;
+        }
+        console.log(chalk.blue.bold(`\n🔑 Translation Keys (${keys.length}${total ? ` of ${total}` : ''})\n`));
+        keys.forEach((key) => {
+            console.log(chalk.white.bold(key.key));
+            if (key.description) {
+                console.log(chalk.gray(`  Description: ${key.description}`));
+            }
+            if (key.module) {
+                console.log(chalk.gray(`  Module: ${key.module}`));
+            }
+            console.log(chalk.gray(`  Published: ${key.published ? chalk.green('Yes') : chalk.yellow('No')}`));
+            const langs = Object.keys(key.translations || {});
+            if (langs.length > 0) {
+                console.log(chalk.gray(`  Languages: ${langs.join(', ')}`));
+            }
+            console.log('');
+        });
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to list keys'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exitCode = 1;
+    }
+}
+/**
+ * Get single key
+ */
+export async function getKeyCommand(projectSlug, keyName) {
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const orgId = config.get('organizationId');
+    if (!orgId) {
+        console.log(chalk.red('✗ Organization ID not found. Please run "langctl auth <api-key>" again.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const spinner = ora('Fetching key...').start();
+    try {
+        const project = await resolveProject(orgId, projectSlug);
+        const key = await findKeyByName(orgId, project.id, keyName);
+        if (!key) {
+            spinner.fail(chalk.red(`Key "${keyName}" not found`));
+            return;
+        }
+        spinner.stop();
+        console.log(chalk.blue.bold('\n🔑 Translation Key Details\n'));
+        console.log(chalk.white.bold(`Key: ${key.key}`));
+        console.log(chalk.gray(`ID: ${key.id}`));
+        if (key.description) {
+            console.log(chalk.gray(`Description: ${key.description}`));
+        }
+        if (key.module) {
+            console.log(chalk.gray(`Module: ${key.module}`));
+        }
+        console.log(chalk.gray(`Published: ${key.published ? chalk.green('Yes') : chalk.yellow('No')}`));
+        console.log(chalk.blue.bold('\nTranslations:'));
+        Object.entries(key.translations || {}).forEach(([lang, value]) => {
+            console.log(chalk.white(`  ${lang}: ${value}`));
+        });
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to get key'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exitCode = 1;
+    }
+}
+/**
+ * Create translation key
+ */
+export async function createKeyCommand(projectSlug, keyName, options) {
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const orgId = config.get('organizationId');
+    if (!orgId) {
+        console.log(chalk.red('✗ Organization ID not found. Please run "langctl auth <api-key>" again.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const spinner = ora('Creating key...').start();
+    try {
+        const project = await resolveProject(orgId, projectSlug);
+        // Build translations object from --value-* options
+        const translations = {};
+        Object.keys(options).forEach(opt => {
+            if (opt.startsWith('value')) {
+                const lang = opt.replace('value', '').toLowerCase();
+                if (lang) {
+                    translations[lang] = options[opt];
+                }
+            }
+        });
+        const api = getApiClient();
+        await api.post(`/orgs/${orgId}/projects/${project.id}/keys`, {
+            key: keyName,
+            translations: Object.keys(translations).length > 0 ? translations : undefined,
+            description: options.description,
+            module: options.module,
+            tags: options.tags ? options.tags.split(',') : undefined
+        });
+        spinner.succeed(chalk.green(`Created key: ${keyName}`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to create key'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exitCode = 1;
+    }
+}
+/**
+ * Delete translation key
+ */
+export async function deleteKeyCommand(projectSlug, keyName) {
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const orgId = config.get('organizationId');
+    if (!orgId) {
+        console.log(chalk.red('✗ Organization ID not found. Please run "langctl auth <api-key>" again.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const spinner = ora('Deleting key...').start();
+    try {
+        const project = await resolveProject(orgId, projectSlug);
+        const key = await findKeyByName(orgId, project.id, keyName);
+        if (!key) {
+            spinner.fail(chalk.red(`Key "${keyName}" not found`));
+            return;
+        }
+        const api = getApiClient();
+        await api.delete(`/orgs/${orgId}/projects/${project.id}/keys/${key.id}`);
+        spinner.succeed(chalk.green(`Deleted key: ${keyName}`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to delete key'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exitCode = 1;
+    }
+}
+/**
+ * Update single translation
+ */
+export async function translateKeyCommand(projectSlug, keyName, options) {
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const orgId = config.get('organizationId');
+    if (!orgId) {
+        console.log(chalk.red('✗ Organization ID not found. Please run "langctl auth <api-key>" again.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const spinner = ora('Updating translation...').start();
+    try {
+        const project = await resolveProject(orgId, projectSlug);
+        const key = await findKeyByName(orgId, project.id, keyName);
+        if (!key) {
+            spinner.fail(chalk.red(`Key "${keyName}" not found`));
+            return;
+        }
+        const api = getApiClient();
+        await api.patch(`/orgs/${orgId}/projects/${project.id}/keys/${key.id}/translations/${options.language}`, { value: options.value });
+        spinner.succeed(chalk.green(`Updated ${options.language} translation for ${keyName}`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to update translation'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exitCode = 1;
+    }
+}
+/**
+ * Publish/unpublish keys
+ */
+export async function publishKeysCommand(projectSlug, keys, options) {
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const orgId = config.get('organizationId');
+    if (!orgId) {
+        console.log(chalk.red('✗ Organization ID not found. Please run "langctl auth <api-key>" again.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const action = options.unpublish ? 'unpublish' : 'publish';
+    const spinner = ora(`${action === 'publish' ? 'Publishing' : 'Unpublishing'} keys...`).start();
+    try {
+        const project = await resolveProject(orgId, projectSlug);
+        // List all keys to match names to IDs
+        const api = getApiClient();
+        const result = await api.get(`/orgs/${orgId}/projects/${project.id}/keys`, {
+            pageSize: '1000'
+        });
+        const keyIds = result.data
+            ?.filter((k) => keys.includes(k.key))
+            .map((k) => k.id) || [];
+        if (keyIds.length === 0) {
+            spinner.fail(chalk.red('No matching keys found'));
+            return;
+        }
+        const response = await api.post(`/orgs/${orgId}/projects/${project.id}/keys/bulk-publish`, { keyIds, published: !options.unpublish });
+        spinner.succeed(chalk.green(response.message || `${action === 'publish' ? 'Published' : 'Unpublished'} ${response.count} key(s)`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail(chalk.red(`Failed to ${action} keys`));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=keys.js.map

package/dist/commands/org.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Get organization information
+ */
+export declare function orgInfoCommand(): Promise<void>;
+/**
+ * Get organization statistics
+ */
+export declare function orgStatsCommand(): Promise<void>;
+/**
+ * Get organization plan and limits
+ */
+export declare function orgPlanCommand(): Promise<void>;
+//# sourceMappingURL=org.d.ts.map

package/dist/commands/org.js

@@ -0,0 +1,118 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { isAuthenticated } from '../auth.js';
+import { getApiClient } from '../api.js';
+import { config } from '../config.js';
+/**
+ * Get organization information
+ */
+export async function orgInfoCommand() {
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const orgId = config.get('organizationId');
+    if (!orgId) {
+        console.log(chalk.red('✗ No organization configured. Please run "langctl init" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const spinner = ora('Fetching organization info...').start();
+    try {
+        const api = getApiClient();
+        const org = await api.get(`/orgs/${orgId}`);
+        spinner.stop();
+        console.log(chalk.blue.bold('\n🏢 Organization Information\n'));
+        console.log(chalk.white.bold(org.name));
+        console.log(chalk.gray(`ID: ${org.id}`));
+        console.log(chalk.gray(`Slug: ${org.slug}`));
+        console.log(chalk.gray(`Plan: ${org.plan}`));
+        console.log(chalk.gray(`Created: ${new Date(org.createdAt).toLocaleDateString()}`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to fetch organization info'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exitCode = 1;
+    }
+}
+/**
+ * Get organization statistics
+ */
+export async function orgStatsCommand() {
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const orgId = config.get('organizationId');
+    if (!orgId) {
+        console.log(chalk.red('✗ No organization configured. Please run "langctl init" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const spinner = ora('Fetching organization statistics...').start();
+    try {
+        const api = getApiClient();
+        const stats = await api.get(`/orgs/${orgId}/stats`);
+        spinner.stop();
+        console.log(chalk.blue.bold('\n📊 Organization Statistics\n'));
+        console.log(chalk.white.bold('Team'));
+        console.log(chalk.gray(`  Members: ${stats.memberCount}`));
+        console.log('');
+        console.log(chalk.white.bold('Projects'));
+        console.log(chalk.gray(`  Total Projects: ${stats.projectCount}`));
+        console.log('');
+        console.log(chalk.white.bold('Translation Keys'));
+        console.log(chalk.gray(`  Total Keys: ${stats.totalKeys}`));
+        console.log('');
+        console.log(chalk.white.bold('Resources'));
+        console.log(chalk.gray(`  API Keys: ${stats.apiKeyCount}`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to fetch statistics'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exitCode = 1;
+    }
+}
+/**
+ * Get organization plan and limits
+ */
+export async function orgPlanCommand() {
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const orgId = config.get('organizationId');
+    if (!orgId) {
+        console.log(chalk.red('✗ No organization configured. Please run "langctl init" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const spinner = ora('Fetching plan information...').start();
+    try {
+        const api = getApiClient();
+        const org = await api.get(`/orgs/${orgId}`);
+        spinner.stop();
+        console.log(chalk.blue.bold('\n💎 Subscription Plan\n'));
+        console.log(chalk.white.bold(`Current Plan: ${org.plan.toUpperCase()}`));
+        console.log('');
+        console.log(chalk.white.bold('Plan Limits'));
+        // Display limits with "Unlimited" for -1 or null values
+        const formatLimit = (value) => (value === -1 || value === null) ? chalk.green('Unlimited') : chalk.gray(value.toString());
+        console.log(chalk.gray(`  Max Members: ${formatLimit(org.maxMembers)}`));
+        console.log(chalk.gray(`  Max Projects: ${formatLimit(org.maxProjects)}`));
+        console.log(chalk.gray(`  Max Keys per Project: ${formatLimit(org.maxKeysPerProject)}`));
+        console.log(chalk.gray(`  Max API Keys: ${formatLimit(org.maxApiKeys)}`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to fetch plan information'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=org.js.map

package/dist/commands/projects.d.ts

@@ -1,2 +1,33 @@
+/**
+ * List all projects
+ */
 export declare function projectsListCommand(): Promise<void>;
+/**
+ * Create new project
+ */
+export declare function projectsCreateCommand(name: string, options: any): Promise<void>;
+/**
+ * Get project details
+ */
+export declare function projectsGetCommand(slug: string): Promise<void>;
+/**
+ * Update project
+ */
+export declare function projectsUpdateCommand(slug: string, options: any): Promise<void>;
+/**
+ * Delete project
+ */
+export declare function projectsDeleteCommand(slug: string): Promise<void>;
+/**
+ * Add language to project
+ */
+export declare function projectsAddLanguageCommand(slug: string, language: string): Promise<void>;
+/**
+ * Remove language from project
+ */
+export declare function projectsRemoveLanguageCommand(slug: string, language: string): Promise<void>;
+/**
+ * Get project statistics
+ */
+export declare function projectsStatsCommand(slug: string): Promise<void>;
 //# sourceMappingURL=projects.d.ts.map