@scalar/cli 2.0.1 → 2.1.0

package/chunks/action-ANU5HGC4.js

@@ -0,0 +1,34 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-SXYALPYK.js";
+import "./chunk-UPUTMFD4.js";
+import "./chunk-B6QZJWCQ.js";
+import "./chunk-P646T2WH.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import "./chunk-4DGQIAJX.js";
+import "./chunk-ISGLWBXZ.js";
+import "./chunk-H2WRMLYY.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/registry/delete/action.ts
+async function deleteAction(namespace, slug) {
+  const client = await apiService();
+  const logger = output.info().line().loader("Deleting the api document");
+  const deleteDocument = await client.managedDocs.delete(namespace, slug);
+  if (deleteDocument.error) {
+    return output.error().title(deleteDocument.message).exit("error");
+  }
+  logger.update("loader", 0, { content: "Successfully deleted document." }).print();
+}
+export {
+  deleteAction
+};

package/chunks/action-BMFXENMX.js

@@ -0,0 +1,176 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  dashboardUrl,
+  registryUrl
+} from "./chunk-T7MDADON.js";
+import {
+  registry
+} from "./chunk-DOVIWNKQ.js";
+import {
+  getFileOrUrl
+} from "./chunk-23I5PKZZ.js";
+import {
+  DEFAULT_FETCH_CONCURRENCY
+} from "./chunk-AHWWJ3MD.js";
+import {
+  apiService
+} from "./chunk-SXYALPYK.js";
+import {
+  BaseCollections
+} from "./chunk-2BSG2QHO.js";
+import {
+  getDatabaseClient
+} from "./chunk-SHSHFGA7.js";
+import "./chunk-UPUTMFD4.js";
+import "./chunk-B6QZJWCQ.js";
+import "./chunk-5BPPGTUU.js";
+import "./chunk-P646T2WH.js";
+import {
+  RegistryAsset
+} from "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import {
+  teamSchema
+} from "./chunk-4DGQIAJX.js";
+import {
+  docVersionSchema,
+  namespaceSchema,
+  slugSchema,
+  toAsciiSlug
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/registry/publish/action.ts
+import { text } from "@clack/prompts";
+import as from "ansis";
+import { bundle } from "@scalar/json-magic/bundle";
+import { fetchUrls, readFiles } from "@scalar/json-magic/bundle/plugins/node";
+import { parseJsonOrYaml } from "@scalar/oas-utils/helpers";
+async function publishAction(file, args) {
+  const { error, data } = external_exports.object({
+    slug: slugSchema.optional(),
+    file: external_exports.string().min(1, "Please provide a valid file path or URL for your document.").optional(),
+    namespace: namespaceSchema.optional(),
+    version: docVersionSchema.optional(),
+    private: external_exports.coerce.boolean(),
+    current: external_exports.coerce.boolean(),
+    force: external_exports.coerce.boolean(),
+    bundle: external_exports.coerce.boolean().optional(),
+    fetchLimit: external_exports.coerce.number().optional(),
+    urlMap: external_exports.coerce.boolean().default(false),
+    treeShake: external_exports.coerce.boolean().default(false)
+  }).safeParse({
+    file,
+    slug: args.slug,
+    namespace: args.namespace,
+    version: args.version,
+    private: args.private,
+    current: args.current,
+    force: args.force
+  });
+  if (error)
+    return output.error().title("Invalid input").message(error.issues[0].message).exit("error");
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const db = await getDatabaseClient();
+  const team = await db.getOne({
+    collectionPath: BaseCollections.Teams,
+    query: {
+      uid: auth.teamUid
+    },
+    schema: teamSchema
+  });
+  if (team.error)
+    return output.error().title("An error occurred when fetching your team.").message(team.message).exit("error");
+  const namespace = data.namespace || team.data.namespaces.at(0);
+  if (!namespace) {
+    return output.error().title("Missing namespace").message(
+      "Could not find a valid namespace for your API. Please specify a namespace or contact support."
+    ).exit("error");
+  }
+  const client = await apiService();
+  const namespaceApisRes = await client.managedDocs.getApiDocs(namespace);
+  if (namespaceApisRes.error)
+    return output.error().title(namespaceApisRes.message).exit("error");
+  const apiFile = data.file || (await text({
+    message: "Please enter a file path or URL for your document",
+    placeholder: "./api.yaml",
+    validate(value) {
+      if (value.length === 0) return "File path or URL is required!";
+    }
+  })).toString();
+  const rawDocument = await getFileOrUrl(apiFile);
+  const parsed = parseJsonOrYaml(rawDocument);
+  if (!rawDocument) {
+    return output.error().title("Invalid file").message("Please provide a valid file path for your document.").exit("error");
+  }
+  const bundlingPlugins = [readFiles()];
+  if (data.bundle) {
+    bundlingPlugins.push(
+      fetchUrls({
+        limit: data.fetchLimit ?? DEFAULT_FETCH_CONCURRENCY
+      })
+    );
+  }
+  const bundledDocument = await bundle(parsed, {
+    plugins: bundlingPlugins,
+    treeShake: data.treeShake,
+    urlMap: data.urlMap
+  });
+  const specification = bundledDocument;
+  const apiSlug = data.slug || toAsciiSlug(specification.info?.title ?? "");
+  const parsedVersion = docVersionSchema.safeParse(
+    data.version || specification.info?.version
+  );
+  const version = parsedVersion.data || (await text({
+    message: "What is the version of your document (e.g. 0.1.0)?",
+    validate(value) {
+      if (value.length === 0) return "Version is required.";
+      if (docVersionSchema.safeParse(value)?.error)
+        return "Version must be a non-empty string";
+    }
+  })).toString();
+  const logger = output.info().line().loader(`Publishing ${apiSlug} to Scalar registry...`);
+  const matchingApi = namespaceApisRes.data.find((api2) => api2.slug === apiSlug);
+  const document = JSON.stringify(bundledDocument);
+  const publishRes = matchingApi ? await client.managedDocs.addVersion(namespace, apiSlug, {
+    document,
+    version,
+    force: data.force,
+    isCurrent: data.current
+  }) : await client.managedDocs.create(namespace, {
+    title: specification.info?.title || "My API",
+    description: specification.info?.description,
+    version,
+    slug: apiSlug,
+    isPrivate: data.private,
+    document
+  });
+  if (publishRes.error)
+    return output.error().title(publishRes.message).exit("error");
+  logger.update("loader", 0, {
+    content: `Successfully published v${version} for ${apiSlug}.`
+  }).line().print();
+  const api = registry(namespace).apis(apiSlug);
+  const apiUrl = dashboardUrl(
+    RegistryAsset.Apis,
+    matchingApi?.uid ?? publishRes.data.uid
+  );
+  output.info().line(`${as.green("\u279C")} ${as.white.bold("View in dashboard:")}`).line(as.cyan(apiUrl)).line().line(`${as.green("\u279C")} ${as.white.bold("Registry Preview:")}`).line(as.cyan(registryUrl(api.url({ version })))).line().line(`${as.green("\u279C")} ${as.white.bold("Registry YAML:")}`).line(as.cyan(registryUrl(api.url({ version, format: "yaml" })))).line().line(`${as.green("\u279C")} ${as.white.bold("Registry JSON:")}`).line(as.cyan(registryUrl(api.url({ version, format: "json" })))).print();
+}
+export {
+  publishAction
+};

package/chunks/action-BNEGJBUH.js

@@ -0,0 +1,38 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  readAndParseConfig,
+  renderConfigError
+} from "./chunk-P2VH7DOC.js";
+import "./chunk-47Y4L5IT.js";
+import "./chunk-5BPPGTUU.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import "./chunk-TLFMATXR.js";
+import "./chunk-ISGLWBXZ.js";
+import "./chunk-H2WRMLYY.js";
+import "./chunk-K74E42RV.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/project/check-config/action.ts
+import as from "ansis";
+async function checkConfigAction(inputArgument) {
+  const result = readAndParseConfig(inputArgument);
+  if (result.success) {
+    output.info().line(
+      `${as.green("[SUCCESS]")} ${as.green("The Scalar Configuration is valid:")} ${as.green(result.filePath)}`
+    ).line(
+      `${as.green("Scalar Configuration validated")} ${as.grey(
+        `in ${as.white.bold(`${result.validationTime} ms`)}`
+      )}
+`
+    ).print();
+  } else {
+    renderConfigError(result.error);
+  }
+}
+export {
+  checkConfigAction
+};

package/chunks/action-BYZUBXVB.js

@@ -0,0 +1,82 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  measureTime
+} from "./chunk-KHDYYVYF.js";
+import "./chunk-23I5PKZZ.js";
+import {
+  DEFAULT_FETCH_CONCURRENCY
+} from "./chunk-AHWWJ3MD.js";
+import {
+  require_dist
+} from "./chunk-K74E42RV.js";
+import {
+  isUrl,
+  isYamlFileName
+} from "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import {
+  __toESM
+} from "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/bundle/action.ts
+var import_yaml = __toESM(require_dist(), 1);
+import fs from "node:fs/promises";
+import path from "node:path";
+import { cwd } from "node:process";
+import { confirm } from "@clack/prompts";
+import as from "ansis";
+import { bundle } from "@scalar/json-magic/bundle";
+import { fetchUrls, readFiles } from "@scalar/json-magic/bundle/plugins/node";
+async function bundleAction(input, {
+  output: outputFilePath,
+  treeShake,
+  urlMap,
+  fetchLimit
+}) {
+  if (!input) {
+    return output.error().title("Missing input").message("Please provide a file path or URL to bundle").exit("error");
+  }
+  const isUrlInput = isUrl(input);
+  if (!outputFilePath) {
+    if (isUrlInput) {
+      return output.error().message(
+        "Please provide an output file using the -o flag when bundling from a URL."
+      ).exit("error");
+    }
+    const shouldContinue = await confirm({
+      message: "No output file specified - this will overwrite the input file. Continue?",
+      initialValue: false
+    });
+    if (shouldContinue !== true) {
+      return output.error().message("Operation cancelled by user").exit("error");
+    }
+  }
+  const outputFileName = outputFilePath ?? input;
+  const isYaml = isYamlFileName(outputFileName);
+  const resolvedInput = isUrlInput ? input : path.resolve(cwd(), input);
+  const { result, executionTimeMs } = await measureTime(
+    () => bundle(resolvedInput, {
+      plugins: [
+        readFiles(),
+        fetchUrls({
+          limit: fetchLimit ?? DEFAULT_FETCH_CONCURRENCY
+        })
+      ],
+      treeShake: !!treeShake,
+      urlMap: !!urlMap
+    })
+  );
+  await fs.writeFile(
+    outputFilePath ?? input,
+    isYaml ? import_yaml.default.stringify(result) : JSON.stringify(result),
+    "utf8"
+  );
+  output.info().message(
+    `${as.green("\u{1F4E6} OpenAPI Schema bundled")} in ${as.white(`${as.bold(`${Math.round(executionTimeMs)}`)} ms`)}`
+  ).print();
+}
+export {
+  bundleAction
+};

package/chunks/action-C5VB4ITT.js

@@ -0,0 +1,132 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  downloadIsolate
+} from "./chunk-TQ5XC2E3.js";
+import {
+  readAndParseConfig,
+  renderConfigError
+} from "./chunk-P2VH7DOC.js";
+import {
+  CONFIG_FILE_DEFAULT,
+  findConfig
+} from "./chunk-47Y4L5IT.js";
+import {
+  ISOLATE_DIR
+} from "./chunk-KWOL7A6J.js";
+import "./chunk-5BPPGTUU.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import {
+  config
+} from "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import "./chunk-4DGQIAJX.js";
+import {
+  ConfigVersion
+} from "./chunk-ISGLWBXZ.js";
+import "./chunk-H2WRMLYY.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/project/preview/action.ts
+import { text } from "@clack/prompts";
+import as from "ansis";
+
+// src/domains/project/preview/v2.ts
+import { spawn } from "node:child_process";
+import path from "node:path";
+async function runIsolate(isolateOptions) {
+  const child = spawn("node", ["dist/isolate-entry.js"], { cwd: ISOLATE_DIR });
+  child.stdin.write(JSON.stringify(isolateOptions));
+  child.stdin.end();
+  child.stdout.pipe(process.stdout);
+  child.stderr.pipe(process.stderr);
+  child.on("close", (code) => {
+    console.log(`Process exited with code ${code}.`);
+  });
+}
+async function getAccessToken() {
+  try {
+    const { accessToken } = await getAuthData({ noExit: true });
+    return accessToken;
+  } catch {
+    output.info().message(
+      "You're not signed in. Private Scalar content will not be fetched."
+    ).print();
+    return "";
+  }
+}
+async function previewV2Project({
+  logLevel,
+  configPath,
+  port,
+  config: config2,
+  host
+}) {
+  const root = path.resolve(path.dirname(configPath), config2.root ?? "./");
+  const relativeConfigPath = path.relative(root, configPath);
+  const accessToken = await getAccessToken();
+  await downloadIsolate();
+  output.info().message("Starting preview...").print();
+  await runIsolate({
+    configPath: relativeConfigPath,
+    projectDir: root,
+    logLevel,
+    domain: "localhost",
+    mode: "preview",
+    previewServerPort: port,
+    registryBaseUrl: config.projects.registry,
+    baseUrl: config.services.api,
+    token: accessToken,
+    host
+  });
+}
+
+// src/domains/project/preview/action.ts
+async function previewAction(__configPath, options) {
+  const _port = Number.parseInt(options.port || "7970", 10);
+  if (Number.isNaN(_port)) {
+    return output.error().title("Invalid port").message("Please provide a valid port number").exit("error");
+  }
+  if (_port < 0 || _port > 65535) {
+    return output.error().title("Invalid port").message("Port number must be between 0 and 65535").exit("error");
+  }
+  const configPath = __configPath || findConfig() || await text({
+    message: "Where is your configuration file located?",
+    defaultValue: CONFIG_FILE_DEFAULT,
+    placeholder: CONFIG_FILE_DEFAULT
+  });
+  const parseConfigResult = readAndParseConfig(configPath);
+  if (!parseConfigResult.success) {
+    renderConfigError(parseConfigResult.error);
+  }
+  if (parseConfigResult.success) {
+    output.info().line(
+      `${as.green("[SUCCESS]")} ${as.green("Configuration is valid:")} ${as.green(parseConfigResult.filePath)}`
+    ).print();
+  }
+  const { config: config2 } = parseConfigResult;
+  if (config2.version === ConfigVersion.V1) {
+    return output.error().title("V1 Preview is no longer supported.").message("Please upgrade your project with `scalar project upgrade`").exit("error");
+  }
+  if (config2.version === ConfigVersion.V2) {
+    await previewV2Project({
+      logLevel: options.logLevel,
+      configPath,
+      config: config2,
+      port: _port,
+      host: options.host
+    });
+    return;
+  }
+}
+export {
+  previewAction
+};

package/chunks/action-CCW66QJN.js

@@ -0,0 +1,72 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  measureTime
+} from "./chunk-KHDYYVYF.js";
+import {
+  getFileOrUrl
+} from "./chunk-23I5PKZZ.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/split/action.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import { text } from "@clack/prompts";
+import as from "ansis";
+import { normalize } from "@scalar/openapi-parser";
+import {
+  createServerWorkspaceStore,
+  WORKSPACE_FILE_NAME
+} from "@scalar/workspace-store/server";
+async function splitAction(input, { output: __outputPath }) {
+  if (!input) {
+    return output.error().title("Missing input").message("Please provide a file path or URL to split").exit("error");
+  }
+  const getOutputPath = async () => {
+    if (__outputPath !== void 0 && typeof __outputPath === "string") {
+      return __outputPath;
+    }
+    const outputPath2 = await text({
+      message: "Where should the chunks be written?",
+      defaultValue: "./assets",
+      placeholder: "./assets"
+    });
+    if (typeof outputPath2 !== "string") {
+      return output.error().message("Operation cancelled by user").exit("error");
+    }
+    return outputPath2;
+  };
+  const outputPath = await getOutputPath();
+  const fileContents = await getFileOrUrl(input);
+  const documentName = "default";
+  const store = await createServerWorkspaceStore({
+    mode: "static",
+    documents: [
+      {
+        name: documentName,
+        // Todo: remove the type casting
+        document: normalize(fileContents)
+      }
+    ],
+    directory: outputPath
+  });
+  const { executionTimeMs } = await measureTime(async () => {
+    await store.generateWorkspaceChunks();
+    const workspaceFilePath = path.join(outputPath, WORKSPACE_FILE_NAME);
+    const sparseDocument = JSON.parse(
+      await fs.readFile(workspaceFilePath, { encoding: "utf-8" })
+    );
+    await fs.writeFile(
+      path.join(outputPath, "out.json"),
+      JSON.stringify(sparseDocument.documents[documentName])
+    );
+    await fs.rm(workspaceFilePath);
+  });
+  output.info().line().title(as.green("Document Split Successfully! \u{1F389}")).line().message(`\u2728 Chunks have been generated at: ${as.blue(outputPath)}`).line(`\u23F1\uFE0F Split completed in ${as.yellow(executionTimeMs.toFixed(2))}ms`).line("").print();
+}
+export {
+  splitAction
+};

package/chunks/action-CLSD7O2R.js

@@ -0,0 +1,60 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getUserTeams
+} from "./chunk-ASMHW5AY.js";
+import {
+  getDatabaseClient
+} from "./chunk-SHSHFGA7.js";
+import "./chunk-B6QZJWCQ.js";
+import {
+  getAuthData,
+  refreshToken
+} from "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-4DGQIAJX.js";
+import "./chunk-ISGLWBXZ.js";
+import "./chunk-H2WRMLYY.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/team/set/action.ts
+import { select } from "@clack/prompts";
+import as from "ansis";
+async function setAction({ team }) {
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  if (!("refreshToken" in auth)) {
+    return output.error().title("Unsupported operation").message(
+      "You can not change the selected team because you are using a personal token, which is related to a specific team. \nTo be able to perform actions on other teams you need to generate a new personal token and login with the new token."
+    ).exit("error");
+  }
+  const client = await getDatabaseClient();
+  const userTeams = await getUserTeams(client, auth.email ?? "");
+  if (userTeams.error) {
+    return output.error().title("An error occurred while getting list of teams.").exit("error");
+  }
+  let teamValue = team;
+  if (!teamValue) {
+    teamValue = await select({
+      message: "Please select one of the teams",
+      options: userTeams.data.map((it) => ({
+        value: it.teamUid,
+        label: it.teamName
+      }))
+    });
+  }
+  const selectedTeam = userTeams.data.find((it) => it.teamUid === teamValue);
+  if (!selectedTeam) {
+    return output.error().title("Invalid team").message("Please choose a valid team id").exit("error");
+  }
+  await refreshToken(auth.refreshToken, teamValue);
+  output.info().message(
+    `Operation ${as.green("successful")}. Selected team: ${as.cyan(selectedTeam.teamName)}`
+  ).print();
+}
+export {
+  setAction
+};

package/chunks/action-CQ56FVES.js

@@ -0,0 +1,65 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getFileOrUrl
+} from "./chunk-23I5PKZZ.js";
+import {
+  config
+} from "./chunk-OAXFCOJV.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/share/action.ts
+import as from "ansis";
+async function shareAction(fileArgument, { token }) {
+  if (!fileArgument) {
+    return output.error().title("Invalid argument").message("Please provide a file path").exit("error");
+  }
+  const url = new URL(config.projects.sandbox);
+  url.pathname = "/api/share";
+  if (token) {
+    url.searchParams.append("token", token);
+  }
+  fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      content: await getFileOrUrl(fileArgument)
+    })
+  }).then((response) => response.json()).then((data) => {
+    const { id, token: newToken } = data;
+    output.info().line(as.green.bold("Your OpenAPI file is public.")).line().table(
+      [
+        [
+          `${as.green("\u279C")} ${as.white.bold("API Reference:")}`,
+          as.cyan(`https://sandbox.scalar.com/p/${id}`)
+        ],
+        [
+          `${as.grey("\u279C")} ${as.grey.bold("Editor:")}`,
+          as.cyan(`https://sandbox.scalar.com/e/${id}`)
+        ],
+        [],
+        [
+          `${as.grey("\u279C")} ${as.grey.bold("OpenAPI JSON:")}`,
+          as.cyan(`https://sandbox.scalar.com/files/${id}/openapi.json`)
+        ],
+        [
+          `${as.grey("\u279C")} ${as.grey.bold("OpenAPI YAML:")}`,
+          as.cyan(`https://sandbox.scalar.com/files/${id}/openapi.yaml`)
+        ]
+      ],
+      { padding: 1 }
+    ).line().line("Use the token to update the existing sandbox:").line().line(
+      `${as.grey("$")} ${as.white.bold("scalar document share --token=")}${as.cyan.bold(`${newToken}`)} `
+    ).line().print();
+  }).catch((error) => {
+    output.error().title("Failed to share the file.").message(`Details: ${error}`).exit("error");
+  });
+}
+export {
+  shareAction
+};