@akanjs/cli 2.4.0 → 2.4.1-rc.0

package/index-5vvwc0cz.js

@@ -0,0 +1,559 @@
+// @bun
+import {
+  FileSys
+} from "./index-61keag0s.js";
+import {
+  Spinner
+} from "./index-6pz1j0zj.js";
+
+// pkgs/@akanjs/devkit/cloud/globalConfig.ts
+import { mkdir } from "fs/promises";
+import dayjs from "dayjs";
+
+// pkgs/@akanjs/devkit/cloud/constants.ts
+var basePath = `${Bun.env.HOME ?? Bun.env.USERPROFILE}/.akan`;
+var configPath = `${basePath}/config.json`;
+var getDefaultHostConfig = (host = GlobalConfig.akanCloudHost) => ({ host });
+var defaultAkanGlobalConfig = {
+  cloudHost: {},
+  remoteEnvServers: {},
+  llm: null
+};
+
+// pkgs/@akanjs/devkit/cloud/globalConfig.ts
+class GlobalConfig {
+  static akanCloudHost = process.env.USE_AKANJS_PKGS === "true" ? `http://localhost:${process.env.CLOUD_HOST_PORT ?? 8283}` : "https://cloud.akanjs.com";
+  static async#getAkanGlobalConfig() {
+    const exists = await FileSys.fileExists(configPath);
+    const akanConfig = exists ? await FileSys.readJson(configPath) : {};
+    return {
+      ...defaultAkanGlobalConfig,
+      ...akanConfig,
+      cloudHost: akanConfig.cloudHost ?? defaultAkanGlobalConfig.cloudHost,
+      remoteEnvServers: akanConfig.remoteEnvServers ?? defaultAkanGlobalConfig.remoteEnvServers
+    };
+  }
+  static async#setAkanGlobalConfig(akanConfig) {
+    await mkdir(basePath, { recursive: true });
+    await Bun.write(configPath, JSON.stringify(akanConfig, null, 2));
+  }
+  static async getHostConfig(host = GlobalConfig.akanCloudHost) {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    return GlobalConfig.toHostConfig(akanConfig.cloudHost[host] ?? getDefaultHostConfig(host));
+  }
+  static async setHostConfig(config = getDefaultHostConfig()) {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    akanConfig.cloudHost[config.host] = GlobalConfig.toHostConfigDto(config);
+    await GlobalConfig.#setAkanGlobalConfig(akanConfig);
+  }
+  static async getLlmConfig() {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    return akanConfig.llm ?? null;
+  }
+  static async setLlmConfig(llmConfig) {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    await GlobalConfig.#setAkanGlobalConfig({ ...akanConfig, llm: llmConfig });
+  }
+  static async getRemoteEnvServers() {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    return akanConfig.remoteEnvServers;
+  }
+  static async setRemoteEnvServer(name, config) {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    await GlobalConfig.#setAkanGlobalConfig({
+      ...akanConfig,
+      remoteEnvServers: {
+        ...akanConfig.remoteEnvServers,
+        [name]: config
+      }
+    });
+  }
+  static async removeRemoteEnvServer(name) {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    const { [name]: _, ...remoteEnvServers } = akanConfig.remoteEnvServers;
+    await GlobalConfig.#setAkanGlobalConfig({
+      ...akanConfig,
+      remoteEnvServers
+    });
+  }
+  static needRefreshToken(accessToken) {
+    return !!accessToken?.expiresAt?.isBefore(dayjs().add(1, "hour"));
+  }
+  static toAccessToken(accessToken) {
+    return {
+      jwt: accessToken.jwt,
+      refreshToken: accessToken.refreshToken ?? null,
+      expiresAt: accessToken.expiresAt ? dayjs(accessToken.expiresAt) : null
+    };
+  }
+  static toAccessTokenDto(accessToken) {
+    return {
+      jwt: accessToken.jwt,
+      refreshToken: accessToken.refreshToken ?? null,
+      expiresAt: accessToken.expiresAt?.toString() ?? null
+    };
+  }
+  static toHostConfigDto(hostConfig) {
+    return {
+      host: hostConfig.host,
+      auth: {
+        accessToken: hostConfig.auth?.accessToken ? GlobalConfig.toAccessTokenDto(hostConfig.auth.accessToken) : undefined,
+        self: hostConfig.auth?.self
+      }
+    };
+  }
+  static toHostConfig(hostConfigDto) {
+    return {
+      host: hostConfigDto.host,
+      auth: {
+        accessToken: hostConfigDto.auth?.accessToken ? GlobalConfig.toAccessToken(hostConfigDto.auth.accessToken) : undefined,
+        self: hostConfigDto.auth?.self
+      }
+    };
+  }
+}
+
+// pkgs/@akanjs/devkit/cloud/cloudApi.ts
+class HttpClient {
+  baseUrl;
+  headers = {};
+  constructor(baseUrl, headers = {}) {
+    this.baseUrl = baseUrl;
+    this.headers = headers;
+  }
+  async get(url, { headers } = {}) {
+    const response = await fetch(`${this.baseUrl}${url}`, {
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers,
+        ...headers
+      }
+    });
+    return await response.json();
+  }
+  async getFile(url, localPath, headers) {
+    const response = await fetch(`${this.baseUrl}${url}`, {
+      headers: { ...this.headers, ...headers }
+    });
+    if (!response.ok)
+      throw new Error(`Failed to download file: ${response.status} ${response.statusText}`);
+    await Bun.write(localPath, response);
+  }
+  async post(url, data, { headers } = {}) {
+    const isFormData = data instanceof FormData;
+    const response = await fetch(`${this.baseUrl}${url}`, {
+      method: "POST",
+      body: isFormData ? data : JSON.stringify(data),
+      headers: isFormData ? { ...this.headers, ...headers } : { "Content-Type": "application/json", ...this.headers, ...headers }
+    });
+    return await response.json();
+  }
+  setHeaders(headers) {
+    Object.assign(this.headers, headers);
+    return this;
+  }
+}
+
+class CloudApi {
+  #api;
+  #accessToken = null;
+  #workspace;
+  host;
+  url;
+  static async fromHost(workspace, host) {
+    const hostConfig = await GlobalConfig.getHostConfig(host);
+    return new CloudApi(workspace, hostConfig);
+  }
+  constructor(workspace, hostConfig) {
+    this.#workspace = workspace;
+    this.#accessToken = hostConfig.auth?.accessToken ?? null;
+    this.host = hostConfig.host;
+    this.url = `${this.host}/api`;
+    this.#api = new HttpClient(this.url);
+    if (this.#accessToken && !GlobalConfig.needRefreshToken(this.#accessToken))
+      this.#api.setHeaders({
+        Authorization: `Bearer ${this.#accessToken.jwt}`
+      });
+  }
+  async uploadEnv(devProjectId, file) {
+    const formData = new FormData;
+    formData.append("devProjectId", devProjectId);
+    formData.append("file", file);
+    const data = await this.#api.post(`/uploadEnv/${devProjectId}`, formData);
+    return data;
+  }
+  async downloadEnv(devProjectId) {
+    const localPath = `${this.#workspace.workspaceRoot}/local/env.tar`;
+    await this.#api.getFile(`/downloadEnv/${devProjectId}`, localPath);
+    return localPath;
+  }
+  async getRemoteAuthToken(remoteId) {
+    try {
+      const accessToken = await this.#api.get(`/getRemoteAuthToken/${remoteId}`);
+      this.#accessToken = GlobalConfig.toAccessToken(accessToken);
+      this.#api.setHeaders({
+        Authorization: `Bearer ${this.#accessToken.jwt}`
+      });
+      return this.#accessToken;
+    } catch (_) {
+      return null;
+    }
+  }
+  async#ensureAccessTokenLive({
+    allowUnauthorized = false
+  } = {}) {
+    if (!this.#accessToken)
+      throw new Error("No access token");
+    const needRefresh = GlobalConfig.needRefreshToken(this.#accessToken);
+    if (!needRefresh)
+      return this.#accessToken;
+    const refreshToken = this.#accessToken?.refreshToken;
+    if (!refreshToken)
+      throw new Error("No refresh token");
+    return await this.refreshAuthToken(refreshToken);
+  }
+  async refreshAuthToken(refreshToken) {
+    const response = await this.#api.post(`/refreshAuthToken`, { refreshToken });
+    this.#accessToken = GlobalConfig.toAccessToken(response);
+    this.#api.setHeaders({ Authorization: `Bearer ${this.#accessToken.jwt}` });
+    return this.#accessToken;
+  }
+  async getRemoteSelf() {
+    try {
+      const data = await this.#api.get(`/getRemoteSelf`);
+      return data;
+    } catch {
+      return null;
+    }
+  }
+}
+// pkgs/@akanjs/devkit/aiEditor.ts
+import { input, select } from "@inquirer/prompts";
+import {
+  AIMessage,
+  HumanMessage,
+  mapChatMessagesToStoredMessages,
+  mapStoredMessagesToChatMessages
+} from "@langchain/core/messages";
+import { ChatDeepSeek } from "@langchain/deepseek";
+import { ChatOpenAI } from "@langchain/openai";
+import { Logger } from "akanjs/common";
+import chalk from "chalk";
+var MAX_ASK_TRY = 300;
+var deepSeekLlmModels = ["deepseek-chat", "deepseek-reasoner"];
+var openAiLlmModels = ["gpt-5.5"];
+var supportedLlmModels = [...deepSeekLlmModels, ...openAiLlmModels];
+var isOpenAiLlmModel = (model) => openAiLlmModels.includes(model);
+var parseTypescriptFileBlocks = (text) => {
+  const fileBlocks = [];
+  const codeBlockRegex = /```(?:typescript|ts|tsx)\s*\n([\s\S]*?)```/gi;
+  const filePathRegex = /^\s*\/\/\s*File:\s*(.+?)\s*$/im;
+  for (const codeBlock of text.matchAll(codeBlockRegex)) {
+    const content = codeBlock[1]?.trim();
+    if (!content)
+      continue;
+    const filePath = filePathRegex.exec(content)?.[1]?.trim();
+    if (!filePath)
+      continue;
+    fileBlocks.push({
+      filePath,
+      content: content.replace(filePathRegex, "").trim()
+    });
+  }
+  return fileBlocks;
+};
+var preserveTypescriptResponseContent = (previousContent, nextContent) => {
+  const previousWrites = parseTypescriptFileBlocks(previousContent);
+  const nextWrites = parseTypescriptFileBlocks(nextContent);
+  if (previousWrites.length > 0 && nextWrites.length === 0)
+    return previousContent;
+  return nextContent;
+};
+
+class AiSession {
+  static #cacheDir = "node_modules/.cache/akan/aiSession";
+  static #chat = null;
+  static async init({ temperature = 0, useExisting = true } = {}) {
+    if (useExisting) {
+      const llmConfig2 = await AiSession.getLlmConfig();
+      if (llmConfig2) {
+        AiSession.#setChatModel(llmConfig2.model, llmConfig2.apiKey);
+        Logger.rawLog(chalk.dim(`\uD83E\uDD16akan editor uses existing LLM config (${llmConfig2.model})`));
+        return AiSession;
+      }
+    } else
+      Logger.rawLog(chalk.yellow("\uD83E\uDD16akan-editor is not initialized. LLM configuration should be set first."));
+    const llmConfig = await AiSession.#requestLlmConfig();
+    const { model, apiKey } = llmConfig;
+    await AiSession.#validateApiKey(model, apiKey);
+    const session = AiSession.#setChatModel(model, apiKey, { temperature });
+    await session.setLlmConfig({ model, apiKey });
+    return session;
+  }
+  static #setChatModel(model, apiKey, { temperature = 0 } = {}) {
+    AiSession.#chat = AiSession.#createChatModel(model, apiKey, {
+      temperature,
+      streaming: true
+    });
+    return AiSession;
+  }
+  static #createChatModel(model, apiKey, { temperature = 0, streaming = false } = {}) {
+    if (isOpenAiLlmModel(model))
+      return new ChatOpenAI({
+        modelName: model,
+        temperature,
+        streaming,
+        openAIApiKey: apiKey
+      });
+    return new ChatDeepSeek({
+      modelName: model,
+      temperature,
+      streaming,
+      apiKey
+    });
+  }
+  static async getLlmConfig() {
+    return await GlobalConfig.getLlmConfig();
+  }
+  static async setLlmConfig(llmConfig) {
+    await GlobalConfig.setLlmConfig(llmConfig);
+    return AiSession;
+  }
+  static async#requestLlmConfig() {
+    const model = await select({
+      message: "Select a LLM model",
+      choices: supportedLlmModels
+    });
+    const apiKey = await input({ message: "Enter your API key" });
+    return { model, apiKey };
+  }
+  static async#validateApiKey(modelName, apiKey) {
+    const spinner = new Spinner("Validating LLM API key...", {
+      prefix: `\uD83E\uDD16akan-editor`
+    }).start();
+    const chat = AiSession.#createChatModel(modelName, apiKey);
+    try {
+      await chat.invoke("Hi, and just say 'ok'");
+      spinner.succeed("LLM API key is valid");
+      return true;
+    } catch (error) {
+      spinner.fail(chalk.red(`LLM API key is invalid. Please check your API key and try again. You can set it again by running "akan set-llm" or reset by running "akan reset-llm"`));
+      throw error;
+    }
+  }
+  static async clearCache(workspaceRoot) {
+    const cacheDir = `${workspaceRoot}/${AiSession.#cacheDir}`;
+    await Bun.$`rm -rf ${cacheDir}`;
+  }
+  messageHistory = [];
+  sessionKey;
+  isCacheLoaded = false;
+  workspace;
+  constructor(type, {
+    workspace,
+    cacheKey,
+    isContinued
+  }) {
+    this.workspace = workspace;
+    this.sessionKey = `${type}${cacheKey ? `-${cacheKey}` : ""}`;
+    if (isContinued)
+      this.#cacheLoadPromise = this.#loadCache();
+  }
+  #cacheLoadPromise = null;
+  async#loadCache() {
+    const cacheFile = `${AiSession.#cacheDir}/${this.sessionKey}.json`;
+    const isCacheExists = await this.workspace.exists(cacheFile);
+    if (isCacheExists)
+      this.messageHistory = mapStoredMessagesToChatMessages(await this.workspace.readJson(cacheFile));
+    else
+      this.messageHistory = [];
+    this.isCacheLoaded = isCacheExists;
+  }
+  async#saveCache() {
+    const cacheFilePath = `${AiSession.#cacheDir}/${this.sessionKey}.json`;
+    await this.workspace.writeJson(cacheFilePath, mapChatMessagesToStoredMessages(this.messageHistory));
+  }
+  async ask(question, {
+    onReasoning = (reasoning) => {
+      Logger.raw(chalk.dim(reasoning));
+    },
+    onChunk = (chunk) => {
+      Logger.raw(chunk);
+    }
+  } = {}) {
+    if (!AiSession.#chat)
+      await AiSession.init();
+    if (this.#cacheLoadPromise)
+      await this.#cacheLoadPromise;
+    if (!AiSession.#chat)
+      throw new Error("Failed to initialize the AI session");
+    const loader = new Spinner(`${AiSession.#chat.model} is thinking...`, {
+      prefix: `\uD83E\uDD16akan-editor`
+    }).start();
+    try {
+      const humanMessage = new HumanMessage(question);
+      this.messageHistory.push(humanMessage);
+      const stream = await AiSession.#chat.stream(this.messageHistory);
+      let reasoningResponse = "", fullResponse = "";
+      for await (const chunk of stream) {
+        if (loader.isSpinning())
+          loader.succeed(`${AiSession.#chat.model} responded`);
+        if (!fullResponse.length) {
+          const reasoningContent = chunk.additional_kwargs.reasoning_content ?? "";
+          if (reasoningContent.length) {
+            reasoningResponse += reasoningContent;
+            onReasoning(reasoningContent);
+            continue;
+          } else if (chunk.content.length) {
+            reasoningResponse += `
+`;
+            onReasoning(reasoningResponse);
+          }
+        }
+        const content = chunk.content;
+        if (typeof content === "string") {
+          fullResponse += content;
+          onChunk(content);
+        }
+      }
+      fullResponse += `
+`;
+      onChunk(`
+`);
+      this.messageHistory.push(new AIMessage(fullResponse));
+      return { content: fullResponse, messageHistory: this.messageHistory };
+    } catch {
+      loader.fail(`${AiSession.#chat.model} failed to respond`);
+      throw new Error("Failed to stream response");
+    }
+  }
+  async edit(question, { onChunk, onReasoning, maxTry = MAX_ASK_TRY, validate, approve, fallbackToPreviousTypescript } = {}) {
+    for (let tryCount = 0;tryCount < maxTry; tryCount++) {
+      let response = await this.ask(question, { onChunk, onReasoning });
+      if (validate?.length && tryCount === 0) {
+        const validateQuestion = `Double check if the response meets the requirements and conditions, and follow the instructions. If not, rewrite it.
+${validate.map((v) => `- ${v}`).join(`
+`)}`;
+        const validateResponse = await this.ask(validateQuestion, {
+          onChunk,
+          onReasoning
+        });
+        response = {
+          ...validateResponse,
+          content: fallbackToPreviousTypescript ? preserveTypescriptResponseContent(response.content, validateResponse.content) : validateResponse.content
+        };
+      }
+      const isConfirmed = approve ? true : await select({
+        message: "Do you want to edit the response?",
+        choices: [
+          { name: "\u2705 Yes, confirm and apply this result", value: true },
+          { name: "\uD83D\uDD04 No, I want to edit it more", value: false }
+        ]
+      });
+      if (isConfirmed) {
+        await this.#saveCache();
+        return response.content;
+      }
+      question = await input({ message: "What do you want to change?" });
+      tryCount++;
+    }
+    throw new Error("Failed to edit");
+  }
+  async editTypescript(question, options = {}) {
+    const content = await this.edit(question, options);
+    return this.#getTypescriptCode(content);
+  }
+  #getTypescriptCode(content) {
+    //! will be deprecated
+    const code = /```(typescript|tsx)([\s\S]*?)```/.exec(content);
+    return code?.[2] ?? content;
+  }
+  addToolMessgaes(messages) {
+    const toolMessages = messages.map((message) => new HumanMessage(message.content));
+    this.messageHistory.push(...toolMessages);
+    return this;
+  }
+  async writeTypescripts(question, executor, options = {}) {
+    const content = await this.edit(question, {
+      ...options,
+      fallbackToPreviousTypescript: true
+    });
+    const writes = this.#getTypescriptCodes(content);
+    if (!writes.length)
+      throw new Error("No parseable TypeScript file blocks were found in the AI response. Include `// File: <path>` in each code block.");
+    for (const write of writes)
+      await executor.writeFile(write.filePath, write.content);
+    return await this.#tryFixTypescripts(writes, executor, options);
+  }
+  async#editTypescripts(question, options = {}, fallbackWrites) {
+    const content = await this.edit(question, {
+      ...options,
+      fallbackToPreviousTypescript: true
+    });
+    const writes = this.#getTypescriptCodes(content);
+    if (!writes.length && fallbackWrites?.length)
+      return fallbackWrites;
+    if (!writes.length)
+      throw new Error("No parseable TypeScript file blocks were found in the AI response. Include `// File: <path>` in each code block.");
+    return writes;
+  }
+  async#tryFixTypescripts(writes, executor, options = {}) {
+    const MAX_EDIT_TRY = 5;
+    for (let tryCount = 0;tryCount < MAX_EDIT_TRY; tryCount++) {
+      const loader = new Spinner(`Type checking and linting...`, {
+        prefix: `\uD83E\uDD16akan-editor`
+      }).start();
+      const fileChecks = await Promise.all(writes.map(async ({ filePath }) => {
+        const lintResult = await executor.lint(filePath, { fix: true });
+        const typeCheckResult = await executor.typeCheckAsync(filePath);
+        const hasTypeErrors = typeCheckResult.fileErrors.length > 0;
+        const hasLintErrors = lintResult.errors.length > 0;
+        const needFix = hasTypeErrors || hasLintErrors;
+        return { filePath, typeCheckResult, lintResult, needFix };
+      }));
+      const hasAnyFix = fileChecks.some((fileCheck) => fileCheck.needFix);
+      if (hasAnyFix) {
+        loader.fail("Type checking and linting has some errors, try to fix them");
+        fileChecks.forEach((fileCheck) => {
+          Logger.rawLog(`TypeCheck Result 
+${fileCheck.typeCheckResult.message}
+Lint Result 
+${fileCheck.lintResult.message}`);
+          this.addToolMessgaes([
+            { type: "typescript", content: fileCheck.typeCheckResult.message },
+            { type: "eslint", content: fileCheck.lintResult.message }
+          ]);
+        });
+        writes = await this.#editTypescripts("Fix the typescript and eslint errors", {
+          ...options,
+          validate: undefined,
+          approve: true
+        }, writes);
+        for (const write of writes)
+          await executor.writeFile(write.filePath, write.content);
+      } else {
+        loader.succeed("Type checking and linting has no errors");
+        return writes;
+      }
+    }
+    throw new Error("Failed to create scalar");
+  }
+  #getTypescriptCodes(text) {
+    return parseTypescriptFileBlocks(text);
+  }
+  async editMarkdown(request, options = {}) {
+    const content = await this.edit(request, options);
+    return this.#getMarkdownContent(content);
+  }
+  #getMarkdownContent(text) {
+    const searchText = "```markdown";
+    const firstIndex = text.indexOf("```markdown");
+    const lastIndex = text.lastIndexOf("```");
+    if (firstIndex === -1)
+      return text;
+    else
+      return text.slice(firstIndex + searchText.length, lastIndex).trim();
+  }
+}
+
+export { getDefaultHostConfig, GlobalConfig, CloudApi, AiSession };

package/index-61keag0s.js

@@ -0,0 +1,40 @@
+// @bun
+// pkgs/@akanjs/devkit/fileSys.ts
+import { stat } from "fs/promises";
+import { Logger } from "akanjs/common";
+
+class FileSys {
+  static logger = new Logger("FileSys");
+  static async fileExists(path) {
+    return await Bun.file(path).exists();
+  }
+  static async dirExists(path) {
+    return await stat(path).then((stat2) => stat2.isDirectory()).catch(() => false);
+  }
+  static async exists(path) {
+    return await stat(path).then(() => true).catch(() => false);
+  }
+  static async readText(path) {
+    return await Bun.file(path).text();
+  }
+  static async readJson(path) {
+    try {
+      return await Bun.file(path).json();
+    } catch (error) {
+      FileSys.logger.error(`Failed to read JSON file: ${path}`);
+      throw error;
+    }
+  }
+  static async delete(path) {
+    return await Bun.file(path).delete();
+  }
+  static async writeText(path, content) {
+    return await Bun.file(path).write(content);
+  }
+  static async writeJson(path, content) {
+    return await Bun.file(path).write(`${JSON.stringify(content, null, 2)}
+`);
+  }
+}
+
+export { FileSys };

package/index-6pz1j0zj.js

@@ -0,0 +1,62 @@
+// @bun
+// pkgs/@akanjs/devkit/spinner.ts
+import ora from "ora";
+
+class Spinner {
+  static padding = 12;
+  spinner;
+  stopWatch = null;
+  startAt = new Date;
+  prefix;
+  message;
+  enableSpin;
+  constructor(message, { prefix = "", indent = 0, enableSpin = true } = {}) {
+    Spinner.padding = Math.max(Spinner.padding, prefix.length);
+    this.prefix = prefix;
+    this.message = message;
+    this.spinner = ora(message);
+    this.spinner.prefixText = prefix.padStart(Spinner.padding, " ");
+    this.spinner.indent = indent;
+    this.enableSpin = enableSpin;
+  }
+  start() {
+    this.startAt = new Date;
+    if (this.enableSpin) {
+      this.spinner.start();
+      this.stopWatch = setInterval(() => {
+        this.spinner.prefixText = this.prefix.padStart(Spinner.padding, " ");
+        this.spinner.text = `${this.message} (${this.#getElapsedTimeStr({ floor: true })})`;
+      }, 1000);
+    } else
+      this.spinner.info();
+    return this;
+  }
+  succeed(message) {
+    this.spinner.succeed(`${message} (${this.#getElapsedTimeStr()})`);
+    this.#reset();
+  }
+  fail(message) {
+    this.spinner.fail(`${message} (${this.#getElapsedTimeStr()})`);
+    this.#reset();
+  }
+  isSpinning() {
+    return this.spinner.isSpinning;
+  }
+  #reset() {
+    if (this.stopWatch)
+      clearInterval(this.stopWatch);
+    this.stopWatch = null;
+  }
+  #getElapsedTimeStr({ floor = false } = {}) {
+    const ms = Date.now() - this.startAt.getTime();
+    if (ms < 1000)
+      return `${ms}ms`;
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+      return `${floor ? Math.floor(ms / 1000) : Math.floor(ms / 100) / 10}s`;
+    const m = Math.floor(s / 60);
+    return `${m}m ${s % 60}s`;
+  }
+}
+
+export { Spinner };