@objectql/cli 1.8.3 → 1.9.0

package/__tests__/commands.test.ts

@@ -1,316 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { newMetadata } from '../src/commands/new';
-import { i18nExtract, i18nInit, i18nValidate } from '../src/commands/i18n';
-import { syncDatabase } from '../src/commands/sync';
-import { ObjectQL } from '@objectql/core';
-import { SqlDriver } from '@objectql/driver-sql';
-import * as yaml from 'js-yaml';
-
-describe('CLI Commands', () => {
-    const testDir = path.join(__dirname, '__test_output__');
-
-    beforeEach(() => {
-        // Create test directory
-        if (!fs.existsSync(testDir)) {
-            fs.mkdirSync(testDir, { recursive: true });
-        }
-    });
-
-    afterEach(() => {
-        // Clean up test directory
-        if (fs.existsSync(testDir)) {
-            fs.rmSync(testDir, { recursive: true, force: true });
-        }
-    });
-
-    describe('new command', () => {
-        it('should create an object file', async () => {
-            await newMetadata({
-                type: 'object',
-                name: 'test_users',
-                dir: testDir
-            });
-
-            const filePath = path.join(testDir, 'test_users.object.yml');
-            expect(fs.existsSync(filePath)).toBe(true);
-
-            const content = fs.readFileSync(filePath, 'utf-8');
-            expect(content).toContain('label: Test Users');
-            expect(content).toContain('type: text');
-        });
-
-        it('should create action with both yml and ts files', async () => {
-            await newMetadata({
-                type: 'action',
-                name: 'test_action',
-                dir: testDir
-            });
-
-            const ymlPath = path.join(testDir, 'test_action.action.yml');
-            const tsPath = path.join(testDir, 'test_action.action.ts');
-
-            expect(fs.existsSync(ymlPath)).toBe(true);
-            expect(fs.existsSync(tsPath)).toBe(true);
-
-            const tsContent = fs.readFileSync(tsPath, 'utf-8');
-            expect(tsContent).toContain('action_test_action');
-            expect(tsContent).toContain('ActionContext');
-        });
-
-        it('should create hook with both yml and ts files', async () => {
-            await newMetadata({
-                type: 'hook',
-                name: 'test_hook',
-                dir: testDir
-            });
-
-            const ymlPath = path.join(testDir, 'test_hook.hook.yml');
-            const tsPath = path.join(testDir, 'test_hook.hook.ts');
-
-            expect(fs.existsSync(ymlPath)).toBe(true);
-            expect(fs.existsSync(tsPath)).toBe(true);
-
-            const tsContent = fs.readFileSync(tsPath, 'utf-8');
-            expect(tsContent).toContain('beforeInsert');
-            expect(tsContent).toContain('afterInsert');
-        });
-
-        // Skip this test as it calls process.exit which causes test failures
-        it.skip('should validate object name format', async () => {
-            await expect(
-                newMetadata({
-                    type: 'object',
-                    name: 'InvalidName',  // Should be lowercase
-                    dir: testDir
-                })
-            ).rejects.toThrow();
-        });
-    });
-
-    describe('i18n commands', () => {
-        beforeEach(async () => {
-            // Create a test object file
-            await newMetadata({
-                type: 'object',
-                name: 'test_users',
-                dir: testDir
-            });
-        });
-
-        it('should extract translatable strings', async () => {
-            await i18nExtract({
-                source: testDir,
-                output: path.join(testDir, 'i18n'),
-                lang: 'en'
-            });
-
-            const i18nFile = path.join(testDir, 'i18n/en/test_users.json');
-            expect(fs.existsSync(i18nFile)).toBe(true);
-
-            const content = JSON.parse(fs.readFileSync(i18nFile, 'utf-8'));
-            expect(content.label).toBe('Test Users');
-            expect(content.fields.name.label).toBe('Name');
-        });
-
-        it('should initialize new language', async () => {
-            await i18nInit({
-                lang: 'zh-CN',
-                baseDir: path.join(testDir, 'i18n')
-            });
-
-            const langDir = path.join(testDir, 'i18n/zh-CN');
-            expect(fs.existsSync(langDir)).toBe(true);
-
-            const commonFile = path.join(langDir, 'common.json');
-            expect(fs.existsSync(commonFile)).toBe(true);
-        });
-
-        it('should validate translations', async () => {
-            // Extract for base language
-            await i18nExtract({
-                source: testDir,
-                output: path.join(testDir, 'i18n'),
-                lang: 'en'
-            });
-
-            // Extract for target language
-            await i18nInit({
-                lang: 'zh-CN',
-                baseDir: path.join(testDir, 'i18n')
-            });
-            await i18nExtract({
-                source: testDir,
-                output: path.join(testDir, 'i18n'),
-                lang: 'zh-CN'
-            });
-
-            // Should not throw - validation passes
-            await expect(
-                i18nValidate({
-                    lang: 'zh-CN',
-                    baseDir: path.join(testDir, 'i18n'),
-                    baseLang: 'en'
-                })
-            ).resolves.not.toThrow();
-        });
-    });
-
-    describe('sync command', () => {
-        let app: ObjectQL;
-        let configPath: string;
-
-        beforeEach(async () => {
-            // Create a test SQLite database with sample schema
-            const dbPath = path.join(testDir, `test_${Date.now()}.db`);
-            const driver = new SqlDriver({
-                client: 'sqlite3',
-                connection: { filename: dbPath },
-                useNullAsDefault: true,
-                pool: { 
-                    min: 1, 
-                    max: 1 // Single connection for test
-                }
-            });
-
-            app = new ObjectQL({
-                datasources: { default: driver }
-            });
-
-            // Register sample objects
-            app.registerObject({
-                name: 'users',
-                label: 'Users',
-                fields: {
-                    username: { type: 'string', required: true, unique: true },
-                    email: { type: 'email', required: true },
-                    is_active: { type: 'boolean', defaultValue: true }
-                }
-            });
-
-            app.registerObject({
-                name: 'posts',
-                label: 'Posts',
-                fields: {
-                    title: { type: 'text', required: true },
-                    content: { type: 'textarea' },
-                    author_id: { type: 'lookup', reference_to: 'users' },
-                    published_at: { type: 'datetime' }
-                }
-            });
-
-            await app.init();
-        });
-
-        afterEach(async () => {
-            try {
-                if (app) await app.close();
-            } catch (e) {
-                // Ignore if already closed
-            }
-        });
-
-        it('should introspect database and generate .object.yml files', async () => {
-            const outputDir = path.join(testDir, 'objects');
-
-            await syncDatabase({
-                app: app,
-                output: outputDir
-            });
-
-            // Check that files were created
-            expect(fs.existsSync(path.join(outputDir, 'users.object.yml'))).toBe(true);
-            expect(fs.existsSync(path.join(outputDir, 'posts.object.yml'))).toBe(true);
-
-            // Verify users.object.yml content
-            const usersContent = fs.readFileSync(path.join(outputDir, 'users.object.yml'), 'utf-8');
-            const usersObj = yaml.load(usersContent) as any;
-            
-            expect(usersObj.name).toBe('users');
-            expect(usersObj.label).toBe('Users');
-            expect(usersObj.fields.username).toBeDefined();
-            expect(usersObj.fields.username.type).toBe('text');
-            expect(usersObj.fields.username.required).toBe(true);
-            expect(usersObj.fields.username.unique).toBe(true);
-            expect(usersObj.fields.email).toBeDefined();
-            expect(usersObj.fields.email.type).toBe('text');
-
-            // Verify posts.object.yml content
-            const postsContent = fs.readFileSync(path.join(outputDir, 'posts.object.yml'), 'utf-8');
-            const postsObj = yaml.load(postsContent) as any;
-            
-            expect(postsObj.name).toBe('posts');
-            expect(postsObj.label).toBe('Posts');
-            expect(postsObj.fields.title).toBeDefined();
-            expect(postsObj.fields.content).toBeDefined();
-            // Foreign key should be detected as lookup
-            expect(postsObj.fields.author_id).toBeDefined();
-            expect(postsObj.fields.author_id.type).toBe('lookup');
-            expect(postsObj.fields.author_id.reference_to).toBe('users');
-        });
-
-        it('should support selective table syncing', async () => {
-            const outputDir = path.join(testDir, 'objects_selective');
-
-            await syncDatabase({
-                app: app,
-                output: outputDir,
-                tables: ['users']
-            });
-
-            // Only users.object.yml should be created
-            expect(fs.existsSync(path.join(outputDir, 'users.object.yml'))).toBe(true);
-            expect(fs.existsSync(path.join(outputDir, 'posts.object.yml'))).toBe(false);
-        });
-
-        it('should skip existing files without --force flag', async () => {
-            const outputDir = path.join(testDir, 'objects_skip');
-
-            // First sync
-            await syncDatabase({
-                app: app,
-                output: outputDir
-            });
-
-            // Modify an existing file
-            const usersPath = path.join(outputDir, 'users.object.yml');
-            const originalContent = fs.readFileSync(usersPath, 'utf-8');
-            fs.writeFileSync(usersPath, '# Modified content\n' + originalContent, 'utf-8');
-
-            // Second sync without force - should skip
-            await syncDatabase({
-                app: app,
-                output: outputDir
-            });
-
-            const modifiedContent = fs.readFileSync(usersPath, 'utf-8');
-            expect(modifiedContent).toContain('# Modified content');
-        });
-
-        it('should overwrite files with --force flag', async () => {
-            const outputDir = path.join(testDir, 'objects_force');
-
-            // First sync
-            await syncDatabase({
-                app: app,
-                output: outputDir
-            });
-
-            // Modify an existing file
-            const usersPath = path.join(outputDir, 'users.object.yml');
-            fs.writeFileSync(usersPath, '# Modified content\nname: users', 'utf-8');
-
-            // Second sync with force - should overwrite
-            await syncDatabase({
-                app: app,
-                output: outputDir,
-                force: true
-            });
-
-            const newContent = fs.readFileSync(usersPath, 'utf-8');
-            expect(newContent).not.toContain('# Modified content');
-            expect(newContent).toContain('name: users');
-            expect(newContent).toContain('fields:');
-        });
-    });
-});

package/dist/commands/studio.d.ts

@@ -1,5 +0,0 @@
-export declare function startStudio(options: {
-    port: number;
-    dir: string;
-    open?: boolean;
-}): Promise<void>;

package/dist/commands/studio.js

@@ -1,364 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startStudio = startStudio;
-const core_1 = require("@objectql/core");
-const platform_node_1 = require("@objectql/platform-node");
-const server_1 = require("@objectql/server");
-const http_1 = require("http");
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-const chalk_1 = __importDefault(require("chalk"));
-const child_process_1 = require("child_process");
-const ts_node_1 = require("ts-node");
-const fast_glob_1 = __importDefault(require("fast-glob"));
-const SWAGGER_HTML = `
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>ObjectQL Swagger UI</title>
-  <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5.11.0/swagger-ui.css" />
-  <style>
-    body { margin: 0; padding: 0; }
-  </style>
-</head>
-<body>
-<div id="swagger-ui"></div>
-<script src="https://unpkg.com/swagger-ui-dist@5.11.0/swagger-ui-bundle.js" crossorigin></script>
-<script>
-  window.onload = () => {
-    window.ui = SwaggerUIBundle({
-      url: '/openapi.json',
-      dom_id: '#swagger-ui',
-    });
-  };
-</script>
-</body>
-</html>
-`;
-function openBrowser(url) {
-    const start = (process.platform == 'darwin' ? 'open' : process.platform == 'win32' ? 'start' : 'xdg-open');
-    (0, child_process_1.exec)(`${start} ${url}`);
-}
-async function startStudio(options) {
-    const startPort = options.port || 5555;
-    const rootDir = path.resolve(process.cwd(), options.dir || '.');
-    console.log(chalk_1.default.blue('Starting ObjectQL Studio...'));
-    console.log(chalk_1.default.gray(`Project Root: ${rootDir}`));
-    // Register ts-node
-    (0, ts_node_1.register)({
-        transpileOnly: true,
-        compilerOptions: {
-            module: "commonjs"
-        }
-    });
-    let app;
-    const configTs = path.join(rootDir, 'objectql.config.ts');
-    const configJs = path.join(rootDir, 'objectql.config.js');
-    if (fs.existsSync(configTs)) {
-        console.log(chalk_1.default.gray(`Loading config from ${configTs}`));
-        const mod = require(configTs);
-        app = mod.default || mod;
-    }
-    else if (fs.existsSync(configJs)) {
-        console.log(chalk_1.default.gray(`Loading config from ${configJs}`));
-        const mod = require(configJs);
-        app = mod.default || mod;
-    }
-    else {
-        console.error(chalk_1.default.red('\n❌ Error: Configuration file (objectql.config.ts) not found.'));
-        process.exit(1);
-    }
-    if (!app) {
-        console.error(chalk_1.default.red('\n❌ Error: No default export found in configuration file.'));
-        process.exit(1);
-    }
-    // Initialize App if it's a configuration object
-    if (typeof app.init !== 'function') {
-        const config = app;
-        console.log(chalk_1.default.gray('Configuration object detected. Initializing ObjectQL instance...'));
-        const datasources = {};
-        if (config.datasource && config.datasource.default) {
-            const dbConfig = config.datasource.default;
-            if (dbConfig.type === 'sqlite') {
-                try {
-                    const { SqlDriver } = require('@objectql/driver-sql');
-                    datasources.default = new SqlDriver({
-                        client: 'sqlite3',
-                        connection: {
-                            filename: dbConfig.filename ? path.resolve(rootDir, dbConfig.filename) : ':memory:'
-                        },
-                        useNullAsDefault: true
-                    });
-                }
-                catch (e) {
-                    console.warn(chalk_1.default.yellow('Failed to load @objectql/driver-sql. Ensure it is installed.'));
-                }
-            }
-        }
-        // Fallback to memory if no datasource
-        if (!datasources.default) {
-            console.warn(chalk_1.default.yellow('No valid datasource found. Using in-memory SQLite.'));
-            const { SqlDriver } = require('@objectql/driver-sql');
-            datasources.default = new SqlDriver({
-                client: 'sqlite3',
-                connection: { filename: ':memory:' },
-                useNullAsDefault: true
-            });
-        }
-        app = new core_1.ObjectQL({ datasources });
-        // Load Schema
-        const loader = new platform_node_1.ObjectLoader(app.metadata);
-        // Load Presets
-        if (Array.isArray(config.presets)) {
-            console.log(chalk_1.default.gray(`Loading ${config.presets.length} presets...`));
-            for (const preset of config.presets) {
-                try {
-                    loader.loadPackage(preset);
-                }
-                catch (e) {
-                    console.warn(chalk_1.default.yellow(`Failed to load preset ${preset}:`), e.message);
-                }
-            }
-        }
-        // Load Schema from Directory
-        // In a monorepo root with presets, scanning everything is dangerous.
-        // We check if we are in a monorepo-like environment.
-        const isMonorepoRoot = fs.existsSync(path.join(rootDir, 'pnpm-workspace.yaml')) || fs.existsSync(path.join(rootDir, 'pnpm-lock.yaml'));
-        // If we are in a likely monorepo root AND have presets, skip recursive scan
-        if (isMonorepoRoot && config.presets && config.presets.length > 0) {
-            console.log(chalk_1.default.yellow('Monorepo root detected with presets. Skipping recursive file scan of root directory to avoid conflicts.'));
-        }
-        else {
-            loader.load(rootDir);
-        }
-    }
-    // 2. Load Schema & Init
-    try {
-        await app.init();
-    }
-    catch (e) {
-        console.error(chalk_1.default.red('❌ Failed to initialize application:'), e.message);
-        process.exit(1);
-    }
-    // 3. Setup HTTP Server
-    const nodeHandler = (0, server_1.createNodeHandler)(app);
-    const studioHandler = (0, server_1.createStudioHandler)();
-    const metadataHandler = (0, server_1.createMetadataHandler)(app);
-    const server = (0, http_1.createServer)(async (req, res) => {
-        var _a, _b, _c, _d, _e, _f;
-        // CORS
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-        if (req.method === 'OPTIONS') {
-            res.writeHead(200);
-            res.end();
-            return;
-        }
-        if (req.url === '/openapi.json') {
-            return nodeHandler(req, res);
-        }
-        if (req.url === '/swagger') {
-            res.writeHead(200, { 'Content-Type': 'text/html' });
-            res.end(SWAGGER_HTML);
-            return;
-        }
-        // Routing
-        if ((_a = req.url) === null || _a === void 0 ? void 0 : _a.startsWith('/studio')) {
-            return studioHandler(req, res);
-        }
-        if ((_b = req.url) === null || _b === void 0 ? void 0 : _b.startsWith('/api/schema/files')) {
-            // List all metadata files
-            try {
-                // Find all *.*.yml files relative to rootDir
-                // Note: User might have configured objectql with specific source paths. 
-                // We ignore common build folders to avoid duplicates/editing compiled files.
-                // We broadly match all objectql-like files: *.object.yml, *.view.yml, etc.
-                const files = await (0, fast_glob_1.default)('**/*.{object,app,view,permission,report,validation,workflow,form,data,hook,action}.yml', {
-                    cwd: rootDir,
-                    ignore: ['node_modules/**', 'dist/**', 'build/**', 'out/**', '.git/**', '.next/**']
-                });
-                res.setHeader('Content-Type', 'application/json');
-                res.end(JSON.stringify({ files }));
-            }
-            catch (e) {
-                res.statusCode = 500;
-                res.end(JSON.stringify({ error: e.message }));
-            }
-            return;
-        }
-        if ((_c = req.url) === null || _c === void 0 ? void 0 : _c.startsWith('/api/schema/content')) {
-            const urlObj = new URL(req.url, `http://${req.headers.host}`);
-            const file = urlObj.searchParams.get('file');
-            if (!file) {
-                res.statusCode = 400;
-                res.end(JSON.stringify({ error: 'Missing file parameter' }));
-                return;
-            }
-            const filePath = path.join(rootDir, file);
-            // Security check
-            if (!filePath.startsWith(rootDir)) {
-                res.statusCode = 403;
-                res.end(JSON.stringify({ error: 'Access denied' }));
-                return;
-            }
-            if (req.method === 'GET') {
-                try {
-                    const content = fs.readFileSync(filePath, 'utf-8');
-                    res.setHeader('Content-Type', 'text/plain'); // Plain text (YAML)
-                    res.end(content);
-                }
-                catch (e) {
-                    res.statusCode = 404;
-                    res.end(JSON.stringify({ error: 'File not found' }));
-                }
-                return;
-            }
-            if (req.method === 'POST') {
-                let body = '';
-                req.on('data', chunk => body += chunk);
-                req.on('end', () => {
-                    try {
-                        fs.writeFileSync(filePath, body, 'utf-8');
-                        res.statusCode = 200;
-                        res.end(JSON.stringify({ success: true }));
-                    }
-                    catch (e) {
-                        res.statusCode = 500;
-                        res.end(JSON.stringify({ error: e.message }));
-                    }
-                });
-                return;
-            }
-        }
-        if ((_d = req.url) === null || _d === void 0 ? void 0 : _d.startsWith('/api/schema/find')) {
-            const urlObj = new URL(req.url, `http://${req.headers.host}`);
-            const objectName = urlObj.searchParams.get('object');
-            if (!objectName) {
-                res.statusCode = 400;
-                res.end(JSON.stringify({ error: 'Missing object parameter' }));
-                return;
-            }
-            try {
-                // Find all object.yml files
-                const files = await (0, fast_glob_1.default)('**/*.object.yml', {
-                    cwd: rootDir,
-                    ignore: ['node_modules/**', 'dist/**', 'build/**', 'out/**', '.git/**', '.next/**']
-                });
-                let foundFile = null;
-                // Naive parsing to find the object definition
-                // We don't use the FULL parser, just checks if "name: objectName" is present
-                for (const file of files) {
-                    const content = fs.readFileSync(path.join(rootDir, file), 'utf-8');
-                    // Simple check: name: <objectName> or name: "<objectName>"
-                    // This creates a regex that looks for `name:` followed by the objectName
-                    // Handles spaces, quotes
-                    const regex = new RegExp(`^\\s*name:\\s*["']?${objectName}["']?\\s*$`, 'm');
-                    if (regex.test(content)) {
-                        foundFile = file;
-                        break;
-                    }
-                }
-                if (foundFile) {
-                    res.setHeader('Content-Type', 'application/json');
-                    res.end(JSON.stringify({ file: foundFile }));
-                }
-                else {
-                    res.statusCode = 404;
-                    res.end(JSON.stringify({ error: 'Object definition file not found' }));
-                }
-            }
-            catch (e) {
-                res.statusCode = 500;
-                res.end(JSON.stringify({ error: e.message }));
-            }
-            return;
-        }
-        if ((_e = req.url) === null || _e === void 0 ? void 0 : _e.startsWith('/api/metadata')) {
-            return metadataHandler(req, res);
-        }
-        if ((_f = req.url) === null || _f === void 0 ? void 0 : _f.startsWith('/api')) {
-            // Strip /api prefix if needed by the handler, 
-            // but ObjectQL node handler usually expects full path or depends on internal routing.
-            // Actually createNodeHandler handles /objectql/v1/ etc? 
-            // Let's assume standard behavior: pass to handler
-            return nodeHandler(req, res);
-        }
-        // Redirect root to studio
-        if (req.url === '/') {
-            res.writeHead(302, { 'Location': '/studio' });
-            res.end();
-            return;
-        }
-        res.statusCode = 404;
-        res.end('Not Found');
-    });
-    const tryListen = (port) => {
-        server.removeAllListeners('error');
-        server.removeAllListeners('listening'); // Prevent stacking callbacks
-        server.on('error', (e) => {
-            if (e.code === 'EADDRINUSE') {
-                if (port - startPort < 10) {
-                    console.log(chalk_1.default.yellow(`Port ${port} is in use, trying ${port + 1}...`));
-                    server.close();
-                    tryListen(port + 1);
-                }
-                else {
-                    console.error(chalk_1.default.red(`❌ Unable to find a free port.`));
-                    process.exit(1);
-                }
-            }
-            else {
-                console.error(chalk_1.default.red('❌ Server error:'), e);
-            }
-        });
-        server.listen(port, () => {
-            const url = `http://localhost:${port}/studio`;
-            console.log(chalk_1.default.green(`\n🚀 Studio running at: ${chalk_1.default.bold(url)}`));
-            console.log(chalk_1.default.gray(`   API endpoint: http://localhost:${port}/api`));
-            if (options.open) {
-                openBrowser(url);
-            }
-        });
-    };
-    tryListen(startPort);
-}
-//# sourceMappingURL=studio.js.map