@nocobase/cli 2.3.0-alpha.1 → 3.0.0-alpha.1

package/dist/lib/portal-source.js

@@ -0,0 +1,523 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { cp, mkdir, mkdtemp, readdir, rename, rm, stat } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import * as tar from 'tar';
+import { executeApiRequest } from './api-client.js';
+import { translateCli } from './cli-locale.js';
+import { buildPortalConfig, buildPortalConfigFromOptions, DEFAULT_PORTAL_GIT_PATH, readPortalConfig, syncPortalConfigToRemote, writePortalConfig, } from './portal-config.js';
+import { buildPortalCommandEnv } from './portal-command-env.js';
+import { buildPortalBasePath, resolvePortalAppFromApiBaseUrl, resolvePortalStoragePath, validatePortalSlug, } from './portal-create.js';
+import { listPortalWorkspaces } from './portal-list.js';
+import { findPortalListItem } from './portal-info.js';
+import { run } from './run-npm.js';
+const execFileAsync = promisify(execFile);
+const portalSourceText = (key, values, fallback) => translateCli(`commands.portalSource.${key}`, values, { fallback });
+const PULL_SOURCE_OPERATION = {
+    method: 'POST',
+    pathTemplate: '/multiPortals:pullSource',
+    hasBody: true,
+    bodyRequired: true,
+    responseType: 'binary',
+    parameters: [
+        {
+            name: 'app',
+            flagName: 'app',
+            in: 'body',
+            required: true,
+        },
+        {
+            name: 'portal',
+            flagName: 'portal',
+            in: 'body',
+            required: true,
+        },
+    ],
+};
+const PUSH_SOURCE_OPERATION = {
+    method: 'POST',
+    pathTemplate: '/multiPortals:pushSource',
+    requestContentType: 'multipart/form-data',
+    hasBody: true,
+    bodyRequired: true,
+    parameters: [
+        {
+            name: 'file',
+            flagName: 'file',
+            in: 'body',
+            required: true,
+            isFile: true,
+        },
+        {
+            name: 'app',
+            flagName: 'app',
+            in: 'body',
+            required: true,
+        },
+        {
+            name: 'portal',
+            flagName: 'portal',
+            in: 'body',
+            required: true,
+        },
+        {
+            name: 'message',
+            flagName: 'message',
+            in: 'body',
+        },
+    ],
+};
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isFile(target) {
+    try {
+        return (await stat(target)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function shouldPackPortalSourceEntry(entryName) {
+    return !entryName
+        .split('/')
+        .some((segment) => segment.startsWith('._') || ['.git', 'node_modules', 'dist', '.DS_Store'].includes(segment));
+}
+function validatePortalSourceTarEntry(entryPath, entry) {
+    if (path.isAbsolute(entryPath) || entryPath.split(/[\\/]+/).includes('..')) {
+        return false;
+    }
+    const tarEntry = entry;
+    if (tarEntry.type === 'SymbolicLink' || tarEntry.type === 'Link' || typeof tarEntry.linkpath === 'string') {
+        return false;
+    }
+    return shouldPackPortalSourceEntry(entryPath);
+}
+async function packPortalSource(portalDir) {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-portal-source-'));
+    const archivePath = path.join(tempDir, 'source.tar.gz');
+    const entries = (await readdir(portalDir)).filter(shouldPackPortalSourceEntry);
+    await tar.create({
+        cwd: portalDir,
+        file: archivePath,
+        gzip: true,
+        filter: (entryPath, entry) => validatePortalSourceTarEntry(entryPath, entry),
+    }, entries);
+    return {
+        archivePath,
+        cleanup: async () => {
+            await rm(tempDir, { recursive: true, force: true });
+        },
+    };
+}
+async function replacePortalSourceFromArchive(params) {
+    const targetExists = await pathExists(params.portalDir);
+    if (targetExists && !params.force) {
+        throw new Error(portalSourceText('errors.workspaceExists', { portalDir: params.portalDir }, `Portal already exists: ${params.portalDir}\nPass --force to delete it and pull again.`));
+    }
+    const parentDir = path.dirname(params.portalDir);
+    const tempDir = await mkdtemp(path.join(parentDir, `.${path.basename(params.portalDir)}-pull-`));
+    try {
+        await tar.extract({
+            file: params.archivePath,
+            cwd: tempDir,
+            strict: true,
+            filter: validatePortalSourceTarEntry,
+        });
+        if (targetExists) {
+            await rm(params.portalDir, { recursive: true, force: true });
+        }
+        await rename(tempDir, params.portalDir);
+    }
+    catch (error) {
+        await rm(tempDir, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function replacePortalSourceFromDirectory(params) {
+    const targetExists = await pathExists(params.portalDir);
+    if (targetExists && !params.force) {
+        throw new Error(portalSourceText('errors.workspaceExists', { portalDir: params.portalDir }, `Portal already exists: ${params.portalDir}\nPass --force to delete it and pull again.`));
+    }
+    const parentDir = path.dirname(params.portalDir);
+    const tempDir = await mkdtemp(path.join(parentDir, `.${path.basename(params.portalDir)}-pull-`));
+    try {
+        await cp(params.sourceDir, tempDir, {
+            recursive: true,
+            filter: (source) => shouldPackPortalSourceEntry(path.relative(params.sourceDir, source)),
+        });
+        if (targetExists) {
+            await rm(params.portalDir, { recursive: true, force: true });
+        }
+        await rename(tempDir, params.portalDir);
+    }
+    catch (error) {
+        await rm(tempDir, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function runGit(args, cwd) {
+    return await execFileAsync('git', args, {
+        cwd,
+        maxBuffer: 10 * 1024 * 1024,
+    });
+}
+async function installPortalDependencies(params) {
+    if (params.installDependencies === false) {
+        return {
+            dependenciesInstalled: false,
+            installSkipped: true,
+        };
+    }
+    if (!(await isFile(path.join(params.portalDir, 'package.json')))) {
+        return {
+            dependenciesInstalled: false,
+            installSkipped: true,
+        };
+    }
+    const runCommand = params.runCommand ?? run;
+    await runCommand('pnpm', ['install'], {
+        cwd: params.portalDir,
+        env: buildPortalCommandEnv(),
+        envMode: 'replace',
+        errorName: 'pnpm install',
+    });
+    return {
+        dependenciesInstalled: true,
+        installSkipped: false,
+    };
+}
+function readSourceRevision(data) {
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        return undefined;
+    }
+    const direct = data.sourceRevision;
+    if (typeof direct === 'string' && direct.trim()) {
+        return direct;
+    }
+    return readSourceRevision(data.data);
+}
+async function resolvePortalSourceContext(options) {
+    const portal = validatePortalSlug(options.portal);
+    const apiBaseUrl = trimValue(options.env.apiBaseUrl);
+    const storagePath = resolvePortalStoragePath(options.env);
+    const { app, appPublicPath } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
+    const portalDir = path.join(storagePath, 'portals', app, portal);
+    const portalBase = buildPortalBasePath({ app, appPublicPath, portal });
+    const mode = options.env.kind;
+    if (mode !== 'local' && mode !== 'docker' && mode !== 'http') {
+        throw new Error(portalSourceText('errors.unsupportedEnvKind', { kind: mode }, `Cannot sync portal source for ${mode} envs in the first version.`));
+    }
+    const list = await listPortalWorkspaces({
+        env: options.env,
+        envName: options.envName,
+        cliVersion: options.cliVersion,
+        apiRequest: options.apiRequest,
+    });
+    const item = findPortalListItem(list.items, portal);
+    if (!item) {
+        throw new Error(portalSourceText('errors.notFound', { portal }, `Portal "${portal}" was not found. Run \`nb portal list\` to see available portals.`));
+    }
+    return {
+        app,
+        portal,
+        portalDir,
+        portalBase,
+        mode,
+        sourceStorage: item.sourceStorage || 'nocobase',
+        gitRepo: item.gitRepo,
+        gitBranch: item.gitBranch || 'main',
+        gitPath: item.gitPath || DEFAULT_PORTAL_GIT_PATH,
+        options: item.options,
+    };
+}
+function buildPortalConfigFromContext(context) {
+    if (Object.keys(context.options).length > 0) {
+        return buildPortalConfigFromOptions(context.options, context.portal);
+    }
+    const sourceStorage = context.sourceStorage || 'nocobase';
+    return buildPortalConfig({
+        portal: context.portal,
+        sourceStorage,
+        gitRepo: sourceStorage === 'git' ? context.gitRepo : undefined,
+        gitBranch: sourceStorage === 'git' ? context.gitBranch : undefined,
+        gitPath: sourceStorage === 'git' ? context.gitPath : undefined,
+    });
+}
+function applyPortalConfigToContext(context, config) {
+    return {
+        ...context,
+        sourceStorage: config.sourceStorage,
+        gitRepo: config.git?.repo ?? '',
+        gitBranch: config.git?.branch ?? 'main',
+        gitPath: config.git?.path ?? DEFAULT_PORTAL_GIT_PATH,
+    };
+}
+function assertGitSourceConfig(context) {
+    if (!context.gitRepo) {
+        throw new Error(portalSourceText('errors.gitRepoMissing', { portal: context.portal }, `Portal "${context.portal}" uses Git source storage, but gitRepo is missing.`));
+    }
+    return {
+        repo: context.gitRepo,
+        branch: context.gitBranch || 'main',
+        gitPath: context.gitPath || DEFAULT_PORTAL_GIT_PATH,
+    };
+}
+function isGitRepositoryRootPath(gitPath) {
+    return gitPath === DEFAULT_PORTAL_GIT_PATH;
+}
+async function copyPortalSourceToGitPath(params) {
+    if (isGitRepositoryRootPath(params.gitPath)) {
+        const existingEntries = await readdir(params.repoDir);
+        await Promise.all(existingEntries
+            .filter((entry) => entry !== '.git')
+            .map((entry) => rm(path.join(params.repoDir, entry), { recursive: true, force: true })));
+        const sourceEntries = (await readdir(params.portalDir)).filter(shouldPackPortalSourceEntry);
+        await Promise.all(sourceEntries.map((entry) => cp(path.join(params.portalDir, entry), path.join(params.repoDir, entry), {
+            recursive: true,
+            filter: (source) => shouldPackPortalSourceEntry(path.relative(params.portalDir, source)),
+        })));
+        return;
+    }
+    const targetDir = path.join(params.repoDir, params.gitPath);
+    await rm(targetDir, { recursive: true, force: true });
+    await mkdir(path.dirname(targetDir), { recursive: true });
+    await cp(params.portalDir, targetDir, {
+        recursive: true,
+        filter: (source) => shouldPackPortalSourceEntry(path.relative(params.portalDir, source)),
+    });
+}
+async function cloneGitSource(params) {
+    const repoDir = path.join(params.cwd, 'repo');
+    try {
+        await runGit(['clone', '--branch', params.branch, params.repo, repoDir]);
+    }
+    catch (error) {
+        if (!params.createBranch) {
+            throw error;
+        }
+        await runGit(['clone', params.repo, repoDir]);
+        await runGit(['checkout', '-B', params.branch], repoDir);
+    }
+    return repoDir;
+}
+async function pullGitPortalSource(params) {
+    const git = assertGitSourceConfig(params.context);
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-portal-git-pull-'));
+    try {
+        const repoDir = await cloneGitSource({
+            repo: git.repo,
+            branch: git.branch,
+            cwd: tempDir,
+            createBranch: true,
+        });
+        const sourceDir = path.join(repoDir, git.gitPath);
+        if (!(await pathExists(sourceDir))) {
+            throw new Error(portalSourceText('errors.gitPathMissing', { gitPath: git.gitPath }, `Git path does not exist in the configured repository: ${git.gitPath}`));
+        }
+        await mkdir(path.dirname(params.context.portalDir), { recursive: true });
+        await replacePortalSourceFromDirectory({
+            sourceDir,
+            portalDir: params.context.portalDir,
+            force: params.force,
+        });
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+async function pushGitPortalSource(params) {
+    const git = assertGitSourceConfig(params.context);
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-portal-git-push-'));
+    try {
+        const repoDir = await cloneGitSource({
+            repo: git.repo,
+            branch: git.branch,
+            cwd: tempDir,
+            createBranch: true,
+        });
+        await copyPortalSourceToGitPath({
+            portalDir: params.context.portalDir,
+            repoDir,
+            gitPath: git.gitPath,
+        });
+        await runGit(['add', git.gitPath], repoDir);
+        const status = await runGit(['status', '--porcelain', '--', git.gitPath], repoDir);
+        if (!status.stdout.trim()) {
+            return undefined;
+        }
+        await runGit([
+            '-c',
+            'user.name=NocoBase CLI',
+            '-c',
+            'user.email=nocobase-cli@localhost',
+            'commit',
+            '-m',
+            trimValue(params.message) || `chore(portal): update ${params.context.portal}`,
+        ], repoDir);
+        await runGit(['push', 'origin', git.branch], repoDir);
+        const revision = await runGit(['rev-parse', 'HEAD'], repoDir);
+        return revision.stdout.trim();
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function pullPortalSource(options) {
+    const context = await resolvePortalSourceContext(options);
+    const portalConfig = buildPortalConfigFromContext(context);
+    const sourceContext = applyPortalConfigToContext(context, portalConfig);
+    if (sourceContext.sourceStorage === 'git') {
+        await pullGitPortalSource({
+            context: sourceContext,
+            force: options.force,
+        });
+        await writePortalConfig(sourceContext.portalDir, portalConfig);
+        const installResult = await installPortalDependencies({
+            portalDir: sourceContext.portalDir,
+            installDependencies: options.installDependencies,
+            runCommand: options.runCommand,
+        });
+        return {
+            ...sourceContext,
+            changed: true,
+            ...installResult,
+        };
+    }
+    if (sourceContext.sourceStorage !== 'nocobase') {
+        throw new Error(portalSourceText('errors.unsupportedSourceStorage', { sourceStorage: sourceContext.sourceStorage }, `Unsupported portal source storage: ${sourceContext.sourceStorage}`));
+    }
+    if (sourceContext.mode === 'local' || sourceContext.mode === 'docker') {
+        return {
+            ...sourceContext,
+            changed: false,
+            noopReason: sourceContext.mode === 'local'
+                ? portalSourceText('messages.localPullNoop', undefined, 'Portal source is already local.')
+                : portalSourceText('messages.dockerPullNoop', undefined, 'Portal source is already available through the Docker volume.'),
+        };
+    }
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-portal-pull-'));
+    const archivePath = path.join(tempDir, 'source.tar.gz');
+    const apiRequest = options.apiRequest ?? executeApiRequest;
+    try {
+        const response = await apiRequest({
+            cliVersion: options.cliVersion ?? '',
+            envName: options.envName,
+            flags: {
+                app: sourceContext.app,
+                portal: sourceContext.portal,
+                output: archivePath,
+            },
+            operation: PULL_SOURCE_OPERATION,
+        });
+        if (!response.ok) {
+            throw new Error(portalSourceText('errors.pullFailed', { status: response.status, details: JSON.stringify(response.data, null, 2) }, `Portal source pull failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`));
+        }
+        await mkdir(path.dirname(sourceContext.portalDir), { recursive: true });
+        await replacePortalSourceFromArchive({
+            archivePath,
+            portalDir: sourceContext.portalDir,
+            force: options.force,
+        });
+        await writePortalConfig(sourceContext.portalDir, portalConfig);
+        const installResult = await installPortalDependencies({
+            portalDir: sourceContext.portalDir,
+            installDependencies: options.installDependencies,
+            runCommand: options.runCommand,
+        });
+        return {
+            ...sourceContext,
+            changed: true,
+            ...installResult,
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function pushPortalSource(options) {
+    const context = await resolvePortalSourceContext(options);
+    if (!(await pathExists(context.portalDir))) {
+        throw new Error(portalSourceText('errors.workspaceMissing', { portalDir: context.portalDir, portal: context.portal }, `Portal does not exist: ${context.portalDir}\nRun \`nb portal create ${context.portal}\` first.`));
+    }
+    const portalConfig = await readPortalConfig(context.portalDir);
+    await syncPortalConfigToRemote({
+        portal: context.portal,
+        config: portalConfig,
+        currentOptions: context.options,
+        envName: options.envName,
+        cliVersion: options.cliVersion,
+        apiRequest: options.apiRequest,
+    });
+    const sourceContext = applyPortalConfigToContext(context, portalConfig);
+    if (sourceContext.sourceStorage === 'git') {
+        const revision = await pushGitPortalSource({
+            context: sourceContext,
+            message: options.message,
+        });
+        return {
+            ...sourceContext,
+            changed: Boolean(revision),
+            sourceRevision: revision,
+            noopReason: revision
+                ? undefined
+                : portalSourceText('messages.gitPushNoop', undefined, 'No local source changes to push.'),
+        };
+    }
+    if (sourceContext.sourceStorage !== 'nocobase') {
+        throw new Error(portalSourceText('errors.unsupportedSourceStorage', { sourceStorage: sourceContext.sourceStorage }, `Unsupported portal source storage: ${sourceContext.sourceStorage}`));
+    }
+    if (sourceContext.mode === 'local' || sourceContext.mode === 'docker') {
+        return {
+            ...sourceContext,
+            changed: false,
+            noopReason: sourceContext.mode === 'local'
+                ? portalSourceText('messages.localPushNoop', undefined, 'Portal source is already local.')
+                : portalSourceText('messages.dockerPushNoop', undefined, 'Portal source is already available through the Docker volume.'),
+        };
+    }
+    const archive = await packPortalSource(sourceContext.portalDir);
+    const apiRequest = options.apiRequest ?? executeApiRequest;
+    try {
+        const response = await apiRequest({
+            cliVersion: options.cliVersion ?? '',
+            envName: options.envName,
+            flags: {
+                file: archive.archivePath,
+                app: sourceContext.app,
+                portal: sourceContext.portal,
+                message: options.message,
+            },
+            operation: PUSH_SOURCE_OPERATION,
+        });
+        if (!response.ok) {
+            throw new Error(portalSourceText('errors.pushFailed', { status: response.status, details: JSON.stringify(response.data, null, 2) }, `Portal source push failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`));
+        }
+        return {
+            ...sourceContext,
+            changed: true,
+            sourceRevision: readSourceRevision(response.data),
+        };
+    }
+    finally {
+        await archive.cleanup();
+    }
+}

package/dist/lib/proxy-caddy.js

@@ -79,6 +79,7 @@ export async function writeCaddyProxyBundle(runtime, appEntryOptions, runtimeCon
         writeFile(bundle.appConfigPath, nextAppConfigContent, 'utf8'),
         writeFile(bundle.indexV1Path, bundle.indexV1Content, 'utf8'),
         writeFile(bundle.indexV2Path, bundle.indexV2Content, 'utf8'),
+        writeFile(bundle.indexSettingsPath, bundle.indexSettingsContent, 'utf8'),
         writeFile(bundle.mainConfigPath, bundle.mainConfigContent, 'utf8'),
     ]);
     return {
@@ -100,6 +101,7 @@ export async function writeManualCaddyProxyBundle(input, appEntryOptions, runtim
         writeFile(bundle.appConfigPath, nextAppConfigContent, 'utf8'),
         writeFile(bundle.indexV1Path, bundle.indexV1Content, 'utf8'),
         writeFile(bundle.indexV2Path, bundle.indexV2Content, 'utf8'),
+        writeFile(bundle.indexSettingsPath, bundle.indexSettingsContent, 'utf8'),
         writeFile(bundle.mainConfigPath, bundle.mainConfigContent, 'utf8'),
     ]);
     return {

package/dist/lib/proxy-nginx.js

@@ -107,6 +107,7 @@ async function writeResolvedNginxProxyBundle(bundle, appEntryOptions, options) {
         writeFile(bundle.appConfigPath, nextAppConfigContent, 'utf8'),
         writeFile(bundle.indexV1Path, bundle.indexV1Content, 'utf8'),
         writeFile(bundle.indexV2Path, bundle.indexV2Content, 'utf8'),
+        writeFile(bundle.indexSettingsPath, bundle.indexSettingsContent, 'utf8'),
         writeFile(bundle.mainConfigPath, bundle.mainConfigContent, 'utf8'),
         syncEnvProxyNginxSnippets(),
     ]);

package/dist/lib/run-npm.js

@@ -48,6 +48,10 @@ const MISSING_COMMAND_SPECS = {
         displayName: 'pnpm',
         configKey: 'bin.pnpm',
     },
+    npm: {
+        displayName: 'npm',
+        configKey: 'bin.npm',
+    },
 };
 const DOCKER_DAEMON_UNAVAILABLE_PATTERNS = [
     /cannot connect to the docker daemon/i,
@@ -61,6 +65,15 @@ async function resolveCommandName(name) {
 function shouldTeeInheritedOutput(options) {
     return options?.stdio === 'inherit' && Boolean(String(process.env.NB_CLI_ACTIVE_LOG_FILE ?? '').trim());
 }
+function buildProcessEnv(options) {
+    if (options?.envMode === 'replace') {
+        return options.env ?? {};
+    }
+    return {
+        ...process.env,
+        ...options?.env,
+    };
+}
 function createMissingCommandError(name, label, error) {
     const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : undefined;
     if (code !== 'ENOENT') {
@@ -146,10 +159,7 @@ export async function run(name, args, options) {
         const child = spawn(command, [...args], {
             stdio,
             cwd,
-            env: {
-                ...process.env,
-                ...options?.env,
-            },
+            env: buildProcessEnv(options),
             windowsHide: process.platform === 'win32',
         });
         if (options?.stdio === 'pipe' || shouldTeeInheritedOutput(options)) {
@@ -268,10 +278,7 @@ export async function commandSucceeds(name, args, options) {
     return await new Promise((resolve, reject) => {
         const child = spawn(command, [...args], {
             cwd,
-            env: {
-                ...process.env,
-                ...options?.env,
-            },
+            env: buildProcessEnv(options),
             stdio: 'ignore',
             windowsHide: process.platform === 'win32',
         });
@@ -302,10 +309,7 @@ export async function commandOutput(name, args, options) {
     return await new Promise((resolve, reject) => {
         const child = spawn(command, [...args], {
             cwd,
-            env: {
-                ...process.env,
-                ...options?.env,
-            },
+            env: buildProcessEnv(options),
             stdio: ['ignore', 'pipe', 'pipe'],
             windowsHide: process.platform === 'win32',
         });
@@ -364,10 +368,7 @@ export async function commandOutputViaFile(name, args, options) {
         const result = await new Promise((resolve, reject) => {
             const child = spawn(command, [...args], {
                 cwd,
-                env: {
-                    ...process.env,
-                    ...options?.env,
-                },
+                env: buildProcessEnv(options),
                 stdio: ['ignore', stdoutHandle.fd, stderrHandle.fd],
                 windowsHide: process.platform === 'win32',
             });

package/dist/lib/ui.js

@@ -15,8 +15,35 @@ let verboseMode = false;
 let lastStaticTaskMessage;
 let lastStaticTaskAt = 0;
 const STATIC_TASK_UPDATE_THROTTLE_MS = 3_000;
+function isCombiningCodePoint(codePoint) {
+    return ((codePoint >= 0x0300 && codePoint <= 0x036f) ||
+        (codePoint >= 0x1ab0 && codePoint <= 0x1aff) ||
+        (codePoint >= 0x1dc0 && codePoint <= 0x1dff) ||
+        (codePoint >= 0x20d0 && codePoint <= 0x20ff) ||
+        (codePoint >= 0xfe20 && codePoint <= 0xfe2f));
+}
+function isFullWidthCodePoint(codePoint) {
+    return (codePoint >= 0x1100 &&
+        (codePoint <= 0x115f ||
+            codePoint === 0x2329 ||
+            codePoint === 0x232a ||
+            (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+            (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+            (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+            (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+            (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+            (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+            (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+            (codePoint >= 0x20000 && codePoint <= 0x3fffd)));
+}
 function stringWidth(value) {
-    return Array.from(value).length;
+    return Array.from(value).reduce((width, character) => {
+        const codePoint = character.codePointAt(0);
+        if (!codePoint || codePoint === 0 || codePoint < 32 || isCombiningCodePoint(codePoint)) {
+            return width;
+        }
+        return width + (isFullWidthCodePoint(codePoint) ? 2 : 1);
+    }, 0);
 }
 function pad(value, width) {
     const padding = Math.max(0, width - stringWidth(value));