@cimplify/cli 0.15.2 → 0.16.0

package/dist/chunk-KQNZKV6E.mjs

@@ -0,0 +1,535 @@
+#!/usr/bin/env node
+// src/interactives/toml.ts
+var TomlSyntaxError = class extends Error {
+  line;
+  column;
+  reason;
+  constructor(reason, at) {
+    super(`${at.line}:${at.column}: ${reason}`);
+    this.name = "TomlSyntaxError";
+    this.reason = reason;
+    this.line = at.line;
+    this.column = at.column;
+  }
+};
+var CH_TAB = 9;
+var CH_LF = 10;
+var CH_CR = 13;
+var CH_SPACE = 32;
+var CH_QUOTE = 34;
+var CH_HASH = 35;
+var CH_APOS = 39;
+var CH_PLUS = 43;
+var CH_COMMA = 44;
+var CH_MINUS = 45;
+var CH_DOT = 46;
+var CH_0 = 48;
+var CH_9 = 57;
+var CH_EQUALS = 61;
+var CH_A = 65;
+var CH_Z = 90;
+var CH_LBRACKET = 91;
+var CH_BACKSLASH = 92;
+var CH_RBRACKET = 93;
+var CH_UNDERSCORE = 95;
+var CH_LOWER_A = 97;
+var CH_LOWER_Z = 122;
+var CH_LBRACE = 123;
+var CH_RBRACE = 125;
+var CH_DEL = 127;
+var DATE_SEPARATOR_INDEX = 4;
+var MAX_CODE_POINT = 1114111;
+var SURROGATE_LOW = 55296;
+var SURROGATE_HIGH = 57343;
+function isBare(c) {
+  return c >= CH_A && c <= CH_Z || c >= CH_LOWER_A && c <= CH_LOWER_Z || c >= CH_0 && c <= CH_9 || c === CH_UNDERSCORE || c === CH_MINUS;
+}
+function isDigit(c) {
+  return c >= CH_0 && c <= CH_9;
+}
+function isControl(c) {
+  return c < CH_SPACE && c !== CH_TAB || c === CH_DEL;
+}
+var Cursor = class {
+  src;
+  pos = 0;
+  line = 1;
+  lineStart = 0;
+  constructor(src) {
+    this.src = src;
+  }
+  at() {
+    return { line: this.line, column: this.pos - this.lineStart + 1 };
+  }
+  peek(offset = 0) {
+    const i = this.pos + offset;
+    return i < this.src.length ? this.src.charCodeAt(i) : -1;
+  }
+  done() {
+    return this.pos >= this.src.length;
+  }
+  fail(reason, at = this.at()) {
+    throw new TomlSyntaxError(reason, at);
+  }
+  advance() {
+    this.pos++;
+  }
+  newline() {
+    if (this.peek() === CH_CR) {
+      if (this.peek(1) !== CH_LF) this.fail("carriage return must be followed by a line feed");
+      this.pos++;
+    }
+    this.pos++;
+    this.line++;
+    this.lineStart = this.pos;
+  }
+  isNewline() {
+    const c = this.peek();
+    return c === CH_LF || c === CH_CR && this.peek(1) === CH_LF;
+  }
+  skipSpaces() {
+    for (; ; ) {
+      const c = this.peek();
+      if (c !== CH_SPACE && c !== CH_TAB) return;
+      this.pos++;
+    }
+  }
+  skipComment() {
+    if (this.peek() !== CH_HASH) return;
+    while (!this.done() && !this.isNewline()) {
+      if (isControl(this.peek())) this.fail("control characters are not allowed in comments");
+      this.pos++;
+    }
+  }
+  skipBlank() {
+    for (; ; ) {
+      this.skipSpaces();
+      this.skipComment();
+      if (!this.isNewline()) return;
+      this.newline();
+    }
+  }
+  endOfLine() {
+    this.skipSpaces();
+    this.skipComment();
+    if (this.done()) return;
+    if (!this.isNewline()) this.fail(`unexpected ${describe(this.peek())} after value`);
+    this.newline();
+  }
+};
+function describe(c) {
+  if (c < 0) return "end of input";
+  if (c === CH_LF || c === CH_CR) return "end of line";
+  return `character '${String.fromCharCode(c)}'`;
+}
+function define(table, part, value) {
+  table.entries.set(part.name, value);
+  table.keyAt.set(part.name, part.at);
+}
+function newTable(at, origin) {
+  return { kind: "table", entries: /* @__PURE__ */ new Map(), keyAt: /* @__PURE__ */ new Map(), at, origin };
+}
+function parseKey(cur) {
+  const parts = [];
+  for (; ; ) {
+    cur.skipSpaces();
+    const at = cur.at();
+    const c = cur.peek();
+    let name;
+    if (c === CH_QUOTE) {
+      if (cur.peek(1) === CH_QUOTE && cur.peek(2) === CH_QUOTE) cur.fail("multi-line strings cannot be keys");
+      name = parseBasicString(cur);
+    } else if (c === CH_APOS) {
+      if (cur.peek(1) === CH_APOS && cur.peek(2) === CH_APOS) cur.fail("multi-line strings cannot be keys");
+      name = parseLiteralString(cur);
+    } else if (isBare(c)) {
+      const start = cur.pos;
+      while (isBare(cur.peek())) cur.advance();
+      name = cur.src.slice(start, cur.pos);
+    } else {
+      cur.fail(`expected a key, found ${describe(c)}`);
+    }
+    parts.push({ name, at });
+    cur.skipSpaces();
+    if (cur.peek() !== CH_DOT) return parts;
+    cur.advance();
+  }
+}
+function parseBasicString(cur) {
+  cur.advance();
+  let out = "";
+  let runStart = cur.pos;
+  for (; ; ) {
+    const c = cur.peek();
+    if (c < 0 || c === CH_LF || c === CH_CR) cur.fail("unterminated string");
+    if (c === CH_QUOTE) {
+      out += cur.src.slice(runStart, cur.pos);
+      cur.advance();
+      return out;
+    }
+    if (c === CH_BACKSLASH) {
+      out += cur.src.slice(runStart, cur.pos);
+      out += parseEscape(cur);
+      runStart = cur.pos;
+      continue;
+    }
+    if (isControl(c)) cur.fail("control characters must be escaped in strings");
+    cur.advance();
+  }
+}
+function parseMultilineBasicString(cur) {
+  cur.pos += 3;
+  if (cur.isNewline()) cur.newline();
+  let out = "";
+  let runStart = cur.pos;
+  for (; ; ) {
+    const c = cur.peek();
+    if (c < 0) cur.fail("unterminated multi-line string");
+    if (c === CH_QUOTE && cur.peek(1) === CH_QUOTE && cur.peek(2) === CH_QUOTE) {
+      let extra = 0;
+      while (extra < 2 && cur.peek(3 + extra) === CH_QUOTE) extra++;
+      out += cur.src.slice(runStart, cur.pos + extra);
+      cur.pos += 3 + extra;
+      return out;
+    }
+    if (c === CH_BACKSLASH) {
+      out += cur.src.slice(runStart, cur.pos);
+      const save = cur.pos;
+      cur.advance();
+      cur.skipSpaces();
+      if (cur.isNewline()) {
+        cur.skipBlank();
+        runStart = cur.pos;
+        continue;
+      }
+      cur.pos = save;
+      out += parseEscape(cur);
+      runStart = cur.pos;
+      continue;
+    }
+    if (cur.isNewline()) {
+      out += cur.src.slice(runStart, cur.pos);
+      out += "\n";
+      cur.newline();
+      runStart = cur.pos;
+      continue;
+    }
+    if (isControl(c)) cur.fail("control characters must be escaped in strings");
+    cur.advance();
+  }
+}
+function parseEscape(cur) {
+  const at = cur.at();
+  cur.advance();
+  const e = cur.peek();
+  cur.advance();
+  switch (e) {
+    case 98:
+      return "\b";
+    case 116:
+      return "	";
+    case 110:
+      return "\n";
+    case 102:
+      return "\f";
+    case 114:
+      return "\r";
+    case 101:
+      return "\x1B";
+    case CH_QUOTE:
+      return '"';
+    case CH_BACKSLASH:
+      return "\\";
+    case 120:
+      return unicodeEscape(cur, 2, at);
+    case 117:
+      return unicodeEscape(cur, 4, at);
+    case 85:
+      return unicodeEscape(cur, 8, at);
+    default:
+      return cur.fail(`invalid escape sequence \\${e < 0 ? "" : String.fromCharCode(e)}`, at);
+  }
+}
+function unicodeEscape(cur, digits, at) {
+  const hex = cur.src.slice(cur.pos, cur.pos + digits);
+  if (hex.length !== digits || !/^[0-9A-Fa-f]+$/.test(hex)) cur.fail(`escape needs ${digits} hex digits`, at);
+  const code = Number.parseInt(hex, 16);
+  if (code > MAX_CODE_POINT || code >= SURROGATE_LOW && code <= SURROGATE_HIGH) {
+    cur.fail("escape is not a Unicode scalar value", at);
+  }
+  cur.pos += digits;
+  return String.fromCodePoint(code);
+}
+function parseLiteralString(cur) {
+  cur.advance();
+  const start = cur.pos;
+  for (; ; ) {
+    const c = cur.peek();
+    if (c < 0 || c === CH_LF || c === CH_CR) cur.fail("unterminated string");
+    if (c === CH_APOS) {
+      const value = cur.src.slice(start, cur.pos);
+      cur.advance();
+      return value;
+    }
+    if (isControl(c)) cur.fail("control characters are not allowed in literal strings");
+    cur.advance();
+  }
+}
+function parseMultilineLiteralString(cur) {
+  cur.pos += 3;
+  if (cur.isNewline()) cur.newline();
+  let out = "";
+  let runStart = cur.pos;
+  for (; ; ) {
+    const c = cur.peek();
+    if (c < 0) cur.fail("unterminated multi-line string");
+    if (c === CH_APOS && cur.peek(1) === CH_APOS && cur.peek(2) === CH_APOS) {
+      let extra = 0;
+      while (extra < 2 && cur.peek(3 + extra) === CH_APOS) extra++;
+      out += cur.src.slice(runStart, cur.pos + extra);
+      cur.pos += 3 + extra;
+      return out;
+    }
+    if (cur.isNewline()) {
+      out += cur.src.slice(runStart, cur.pos);
+      out += "\n";
+      cur.newline();
+      runStart = cur.pos;
+      continue;
+    }
+    if (isControl(c)) cur.fail("control characters are not allowed in literal strings");
+    cur.advance();
+  }
+}
+var INTEGER_DEC = /^[+-]?(0|[1-9](_?[0-9])*)$/;
+var INTEGER_HEX = /^0x[0-9A-Fa-f](_?[0-9A-Fa-f])*$/;
+var INTEGER_OCT = /^0o[0-7](_?[0-7])*$/;
+var INTEGER_BIN = /^0b[01](_?[01])*$/;
+var FLOAT = /^[+-]?(0|[1-9](_?[0-9])*)(\.[0-9](_?[0-9])*)?([eE][+-]?[0-9](_?[0-9])*)?$/;
+var FLOAT_SPECIAL = /^[+-]?(inf|nan)$/;
+function parseNumberOrBool(cur) {
+  const at = cur.at();
+  const start = cur.pos;
+  for (; ; ) {
+    const c = cur.peek();
+    if (isBare(c) || c === CH_PLUS || c === CH_DOT) {
+      cur.advance();
+      continue;
+    }
+    break;
+  }
+  const raw = cur.src.slice(start, cur.pos);
+  if (raw.length === 0) cur.fail(`expected a value, found ${describe(cur.peek())}`, at);
+  if (raw === "true") return { kind: "boolean", value: true, at };
+  if (raw === "false") return { kind: "boolean", value: false, at };
+  if (raw.length > DATE_SEPARATOR_INDEX && isDigit(raw.charCodeAt(0)) && raw.charCodeAt(DATE_SEPARATOR_INDEX) === CH_MINUS) {
+    cur.fail("dates and times are not supported in this file", at);
+  }
+  if (cur.peek() === 58) cur.fail("dates and times are not supported in this file", at);
+  if (INTEGER_DEC.test(raw)) return integer(cur, Number(raw.replaceAll("_", "")), at);
+  if (INTEGER_HEX.test(raw) || INTEGER_OCT.test(raw) || INTEGER_BIN.test(raw)) {
+    return integer(cur, Number(raw.replaceAll("_", "")), at);
+  }
+  if (FLOAT_SPECIAL.test(raw)) {
+    const negative = raw.charCodeAt(0) === CH_MINUS;
+    const value = raw.endsWith("nan") ? Number.NaN : negative ? -Infinity : Infinity;
+    return { kind: "float", value, at };
+  }
+  if (FLOAT.test(raw)) return { kind: "float", value: Number(raw.replaceAll("_", "")), at };
+  return cur.fail(`invalid value '${raw}'`, at);
+}
+function integer(cur, value, at) {
+  if (!Number.isSafeInteger(value)) cur.fail("integer is outside the safe range", at);
+  return { kind: "integer", value, at };
+}
+function parseValue(cur) {
+  const at = cur.at();
+  const c = cur.peek();
+  if (c === CH_QUOTE) {
+    if (cur.peek(1) === CH_QUOTE && cur.peek(2) === CH_QUOTE) {
+      return { kind: "string", value: parseMultilineBasicString(cur), at };
+    }
+    return { kind: "string", value: parseBasicString(cur), at };
+  }
+  if (c === CH_APOS) {
+    if (cur.peek(1) === CH_APOS && cur.peek(2) === CH_APOS) {
+      return { kind: "string", value: parseMultilineLiteralString(cur), at };
+    }
+    return { kind: "string", value: parseLiteralString(cur), at };
+  }
+  if (c === CH_LBRACKET) return parseArray(cur);
+  if (c === CH_LBRACE) return parseInlineTable(cur);
+  return parseNumberOrBool(cur);
+}
+function parseArray(cur) {
+  const at = cur.at();
+  cur.advance();
+  const items = [];
+  for (; ; ) {
+    cur.skipBlank();
+    if (cur.peek() === CH_RBRACKET) {
+      cur.advance();
+      return { kind: "array", items, at, ofTables: false };
+    }
+    items.push(parseValue(cur));
+    cur.skipBlank();
+    const c = cur.peek();
+    if (c === CH_COMMA) {
+      cur.advance();
+      continue;
+    }
+    if (c === CH_RBRACKET) {
+      cur.advance();
+      return { kind: "array", items, at, ofTables: false };
+    }
+    cur.fail(`expected ',' or ']' in array, found ${describe(c)}`);
+  }
+}
+function parseInlineTable(cur) {
+  const table = newTable(cur.at(), "inline");
+  cur.advance();
+  cur.skipSpaces();
+  if (cur.peek() === CH_RBRACE) {
+    cur.advance();
+    return table;
+  }
+  for (; ; ) {
+    const key = parseKey(cur);
+    if (cur.peek() !== CH_EQUALS) cur.fail(`expected '=' after key, found ${describe(cur.peek())}`);
+    cur.advance();
+    cur.skipSpaces();
+    const value = parseValue(cur);
+    assignDotted(cur, table, key, value, "inline");
+    cur.skipSpaces();
+    const c = cur.peek();
+    if (c === CH_COMMA) {
+      cur.advance();
+      cur.skipSpaces();
+      if (cur.peek() === CH_RBRACE) cur.fail("trailing comma is not allowed in an inline table");
+      continue;
+    }
+    if (c === CH_RBRACE) {
+      cur.advance();
+      return table;
+    }
+    cur.fail(`expected ',' or '}' in inline table, found ${describe(c)}`);
+  }
+}
+function joinKey(parts, upTo) {
+  let out = "";
+  for (let i = 0; i <= upTo; i++) out += i === 0 ? parts[i].name : `.${parts[i].name}`;
+  return out;
+}
+function assignDotted(cur, root, key, value, scope) {
+  let table = root;
+  for (let i = 0; i < key.length - 1; i++) {
+    const part = key[i];
+    const existing = table.entries.get(part.name);
+    if (existing === void 0) {
+      const child = newTable(part.at, "dotted");
+      define(table, part, child);
+      table = child;
+      continue;
+    }
+    if (existing.kind !== "table" || existing.origin === "inline" || scope === "body" && existing.origin === "header") {
+      cur.fail(`key '${joinKey(key, i)}' is already defined`, part.at);
+    }
+    if (scope === "body" && existing.origin === "implicit") {
+      cur.fail(`key '${joinKey(key, i)}' is already defined as a table`, part.at);
+    }
+    table = existing;
+  }
+  const last = key[key.length - 1];
+  if (table.entries.has(last.name)) cur.fail(`key '${joinKey(key, key.length - 1)}' is already defined`, last.at);
+  define(table, last, value);
+}
+function openHeader(cur, root, key, arrayOfTables) {
+  let table = root;
+  for (let i = 0; i < key.length - 1; i++) {
+    const part = key[i];
+    const existing2 = table.entries.get(part.name);
+    if (existing2 === void 0) {
+      const child = newTable(part.at, "implicit");
+      define(table, part, child);
+      table = child;
+      continue;
+    }
+    if (existing2.kind === "array" && existing2.ofTables) {
+      table = existing2.items[existing2.items.length - 1];
+      continue;
+    }
+    if (existing2.kind !== "table" || existing2.origin === "inline") {
+      cur.fail(`key '${joinKey(key, i)}' is already defined as a value`, part.at);
+    }
+    table = existing2;
+  }
+  const last = key[key.length - 1];
+  const existing = table.entries.get(last.name);
+  if (arrayOfTables) {
+    const element = newTable(last.at, "array_element");
+    if (existing === void 0) {
+      define(table, last, { kind: "array", items: [element], at: last.at, ofTables: true });
+      return element;
+    }
+    if (existing.kind !== "array" || !existing.ofTables) {
+      cur.fail(`key '${joinKey(key, key.length - 1)}' is already defined and is not an array of tables`, last.at);
+    }
+    existing.items.push(element);
+    return element;
+  }
+  if (existing === void 0) {
+    const child = newTable(last.at, "header");
+    define(table, last, child);
+    return child;
+  }
+  if (existing.kind === "table" && existing.origin === "implicit") {
+    existing.origin = "header";
+    return existing;
+  }
+  return cur.fail(`table '${joinKey(key, key.length - 1)}' is already defined`, last.at);
+}
+function parseToml(source) {
+  const cur = new Cursor(source.charCodeAt(0) === 65279 ? source.slice(1) : source);
+  const root = newTable({ line: 1, column: 1 }, "root");
+  let current = root;
+  for (; ; ) {
+    cur.skipBlank();
+    if (cur.done()) return root;
+    if (cur.peek() === CH_LBRACKET) {
+      const arrayOfTables = cur.peek(1) === CH_LBRACKET;
+      cur.pos += arrayOfTables ? 2 : 1;
+      const key2 = parseKey(cur);
+      if (cur.peek() !== CH_RBRACKET || arrayOfTables && cur.peek(1) !== CH_RBRACKET) {
+        cur.fail(arrayOfTables ? "expected ']]' to close the table header" : "expected ']' to close the table header");
+      }
+      cur.pos += arrayOfTables ? 2 : 1;
+      current = openHeader(cur, root, key2, arrayOfTables);
+      cur.endOfLine();
+      continue;
+    }
+    const key = parseKey(cur);
+    if (cur.peek() !== CH_EQUALS) cur.fail(`expected '=' after key, found ${describe(cur.peek())}`);
+    cur.advance();
+    cur.skipSpaces();
+    if (cur.done() || cur.isNewline()) cur.fail("expected a value after '='");
+    const value = parseValue(cur);
+    assignDotted(cur, current, key, value, "body");
+    cur.endOfLine();
+  }
+}
+function quoteTomlString(value) {
+  let out = '"';
+  for (let i = 0; i < value.length; i++) {
+    const c = value.charCodeAt(i);
+    if (c === CH_QUOTE) out += '\\"';
+    else if (c === CH_BACKSLASH) out += "\\\\";
+    else if (c === CH_LF) out += "\\n";
+    else if (c === CH_TAB) out += "\\t";
+    else if (c === CH_CR) out += "\\r";
+    else if (c < CH_SPACE || c === CH_DEL) out += `\\u${c.toString(16).padStart(4, "0")}`;
+    else out += value[i];
+  }
+  return `${out}"`;
+}
+
+export { TomlSyntaxError, parseToml, quoteTomlString };

package/dist/{chunk-MXYUAJEW.mjs → chunk-LLRUOIMU.mjs}

@@ -35,15 +35,18 @@ var DOMAIN_TYPE = {
 var SECRET_MASK = "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
 var PUBLIC_ENV_PREFIX = "NEXT_PUBLIC_";
 var REPO_PROVIDER = {
-  FREESTYLE: "freestyle",
+  CODE_STORAGE: "code_storage",
   GITHUB: "github",
   GITEA: "gitea",
   EXTERNAL: "external"
 };
+function isManagedRepoProvider(provider) {
+  return provider === REPO_PROVIDER.CODE_STORAGE;
+}
 var REPO_PROVIDER_VALUES = new Set(Object.values(REPO_PROVIDER));
 var TOKEN_PURPOSE = {
   BUILD: "build",
   EDITOR: "editor"
 };
 
-export { DEPLOYMENT_STATUS, DEPLOY_TRIGGER, DOMAIN_TYPE, ENV_SCOPE, PUBLIC_ENV_PREFIX, REPO_PROVIDER, REPO_PROVIDER_VALUES, SECRET_MASK, TERMINAL_DEPLOYMENT_STATUSES, TOKEN_PURPOSE };
+export { DEPLOYMENT_STATUS, DEPLOY_TRIGGER, DOMAIN_TYPE, ENV_SCOPE, PUBLIC_ENV_PREFIX, REPO_PROVIDER, REPO_PROVIDER_VALUES, SECRET_MASK, TERMINAL_DEPLOYMENT_STATUSES, TOKEN_PURPOSE, isManagedRepoProvider };

package/dist/{chunk-F2UI225N.mjs → chunk-LNMITJ4Z.mjs}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { parseEnvFile, formatEnvFile } from './chunk-I2UP7YTG.mjs';
-import { ENV_SCOPE, PUBLIC_ENV_PREFIX } from './chunk-MXYUAJEW.mjs';
-import { parseArgs, flagBool } from './chunk-5KYR6WJB.mjs';
-import { ApiClient } from './chunk-NYXA6X56.mjs';
-import { readAuth, readProjectLink } from './chunk-MLE4MVYC.mjs';
-import { info, CliError, CLI_ERROR_CODE, dim } from './chunk-3QUK5BPY.mjs';
+import { parseEnvFile, formatEnvFile } from './chunk-SAXGWS2K.mjs';
+import { ENV_SCOPE, PUBLIC_ENV_PREFIX } from './chunk-LLRUOIMU.mjs';
+import { parseArgs, flagBool } from './chunk-XQAHREKO.mjs';
+import { ApiClient } from './chunk-CLQYPTJ2.mjs';
+import { readAuth, readProjectLink } from './chunk-TT4YI33G.mjs';
+import { info, CliError, CLI_ERROR_CODE, dim } from './chunk-KOD4GBQ5.mjs';
 import { spawn } from 'child_process';
 import { promises } from 'fs';
 import path from 'path';