typescript.cc

#include <sourcemeta/codegen/generator.h>

#include <algorithm> // std::ranges::any_of
#include <iomanip>   // std::hex, std::setfill, std::setw
#include <sstream>   // std::ostringstream

namespace {

// TODO: Move to Core
auto escape_string(const std::string &input) -> std::string {
  std::ostringstream result;
  for (const auto character : input) {
    switch (character) {
      case '\\':
        result << "\\\\";
        break;
      case '"':
        result << "\\\"";
        break;
      case '\b':
        result << "\\b";
        break;
      case '\f':
        result << "\\f";
        break;
      case '\n':
        result << "\\n";
        break;
      case '\r':
        result << "\\r";
        break;
      case '\t':
        result << "\\t";
        break;
      default:
        // Escape other control characters (< 0x20) using \uXXXX format
        if (static_cast<unsigned char>(character) < 0x20) {
          result << "\\u" << std::hex << std::setfill('0') << std::setw(4)
                 << static_cast<int>(static_cast<unsigned char>(character));
        } else {
          result << character;
        }
        break;
    }
  }

  return result.str();
}

} // namespace

namespace sourcemeta::codegen {

TypeScript::TypeScript(std::ostream &stream, const std::string_view type_prefix)
    : output{stream}, prefix{type_prefix} {}

auto TypeScript::operator()(const IRScalar &entry) -> void {
  this->output << "export type "
               << mangle(this->prefix, entry.pointer, entry.symbol, this->cache)
               << " = ";

  switch (entry.value) {
    case IRScalarType::String:
      this->output << "string";
      break;
    case IRScalarType::Number:
    case IRScalarType::Integer:
      this->output << "number";
      break;
    case IRScalarType::Boolean:
      this->output << "boolean";
      break;
    case IRScalarType::Null:
      this->output << "null";
      break;
  }

  this->output << ";\n";
}

auto TypeScript::operator()(const IREnumeration &entry) -> void {
  this->output << "export type "
               << mangle(this->prefix, entry.pointer, entry.symbol, this->cache)
               << " = ";

  const char *separator{""};
  for (const auto &value : entry.values) {
    this->output << separator;
    sourcemeta::core::prettify(value, this->output);
    separator = " | ";
  }

  this->output << ";\n";
}

auto TypeScript::operator()(const IRObject &entry) -> void {
  const auto type_name{
      mangle(this->prefix, entry.pointer, entry.symbol, this->cache)};
  const auto has_typed_additional{
      std::holds_alternative<IRType>(entry.additional)};
  const auto allows_any_additional{
      std::holds_alternative<bool>(entry.additional) &&
      std::get<bool>(entry.additional)};

  if (has_typed_additional && entry.members.empty() && entry.pattern.empty()) {
    const auto &additional_type{std::get<IRType>(entry.additional)};
    this->output << "export type " << type_name << " = Record<string, "
                 << mangle(this->prefix, additional_type.pointer,
                           additional_type.symbol, this->cache)
                 << ">;\n";
    return;
  }

  if (allows_any_additional && entry.members.empty() && entry.pattern.empty()) {
    this->output << "export type " << type_name
                 << " = Record<string, unknown>;\n";
    return;
  }

  this->output << "export interface " << type_name << " {\n";

  // We always quote property names for safety. JSON Schema allows any string
  // as a property name, but unquoted TypeScript/ECMAScript property names
  // must be valid IdentifierName productions (see ECMA-262 section 12.7).
  // Quoting allows any string to be used as a property name.
  // See: https://tc39.es/ecma262/#sec-names-and-keywords
  // See: https://mathiasbynens.be/notes/javascript-properties
  for (const auto &[member_name, member_value] : entry.members) {
    const auto optional_marker{member_value.required ? "" : "?"};
    const auto readonly_marker{member_value.immutable ? "readonly " : ""};

    this->output << "  " << readonly_marker << "\""
                 << escape_string(member_name) << "\"" << optional_marker
                 << ": "
                 << mangle(this->prefix, member_value.pointer,
                           member_value.symbol, this->cache)
                 << ";\n";
  }

  for (const auto &pattern_property : entry.pattern) {
    if (!pattern_property.prefix.has_value()) {
      continue;
    }

    this->output << "  [key: `" << pattern_property.prefix.value()
                 << "${string}`]: "
                 << mangle(this->prefix, pattern_property.pointer,
                           pattern_property.symbol, this->cache);

    // TypeScript requires that a more specific index signature type is
    // assignable to any less specific one that overlaps it. When a prefix
    // is a sub-prefix of another (i.e. "x-data-" starts with "x-"),
    // intersect the types so the constraint is satisfied
    for (const auto &other : entry.pattern) {
      if (&other == &pattern_property || !other.prefix.has_value()) {
        continue;
      }

      if (pattern_property.prefix.value().starts_with(other.prefix.value())) {
        this->output << " & "
                     << mangle(this->prefix, other.pointer, other.symbol,
                               this->cache);
      }
    }

    this->output << ";\n";
  }

  const auto has_non_prefix_pattern{
      std::ranges::any_of(entry.pattern, [](const auto &pattern_property) {
        return !pattern_property.prefix.has_value();
      })};

  if (allows_any_additional) {
    this->output << "  [key: string]: unknown | undefined;\n";
  } else if (has_typed_additional || has_non_prefix_pattern) {
    // TypeScript index signatures must be a supertype of all property value
    // types. We use a union of all member types plus the additional properties
    // type plus undefined (for optional properties).
    this->output << "  [key: string]:\n";
    this->output << "    // As a notable limitation, TypeScript requires index "
                    "signatures\n";
    this->output << "    // to also include the types of all of its "
                    "properties, so we must\n";
    this->output << "    // match a superset of what JSON Schema allows\n";
    for (const auto &[member_name, member_value] : entry.members) {
      this->output << "    "
                   << mangle(this->prefix, member_value.pointer,
                             member_value.symbol, this->cache)
                   << " |\n";
    }

    for (const auto &pattern_property : entry.pattern) {
      this->output << "    "
                   << mangle(this->prefix, pattern_property.pointer,
                             pattern_property.symbol, this->cache)
                   << " |\n";
    }

    if (has_typed_additional) {
      const auto &additional_type{std::get<IRType>(entry.additional)};
      this->output << "    "
                   << mangle(this->prefix, additional_type.pointer,
                             additional_type.symbol, this->cache)
                   << " |\n";
    }

    this->output << "    undefined;\n";
  }

  this->output << "}\n";
}

auto TypeScript::operator()(const IRImpossible &entry) -> void {
  this->output << "export type "
               << mangle(this->prefix, entry.pointer, entry.symbol, this->cache)
               << " = never;\n";
}

auto TypeScript::operator()(const IRAny &entry) -> void {
  this->output << "export type "
               << mangle(this->prefix, entry.pointer, entry.symbol, this->cache)
               << " = unknown;\n";
}

auto TypeScript::operator()(const IRArray &entry) -> void {
  this->output << "export type "
               << mangle(this->prefix, entry.pointer, entry.symbol, this->cache)
               << " = ";

  if (entry.items.has_value()) {
    this->output << mangle(this->prefix, entry.items->pointer,
                           entry.items->symbol, this->cache)
                 << "[]";
  } else {
    this->output << "unknown[]";
  }

  this->output << ";\n";
}

auto TypeScript::operator()(const IRReference &entry) -> void {
  this->output << "export type "
               << mangle(this->prefix, entry.pointer, entry.symbol, this->cache)
               << " = "
               << mangle(this->prefix, entry.target.pointer,
                         entry.target.symbol, this->cache)
               << ";\n";
}

auto TypeScript::operator()(const IRTuple &entry) -> void {
  this->output << "export type "
               << mangle(this->prefix, entry.pointer, entry.symbol, this->cache)
               << " = [";

  const char *separator{""};
  for (const auto &item : entry.items) {
    this->output << separator
                 << mangle(this->prefix, item.pointer, item.symbol,
                           this->cache);
    separator = ", ";
  }

  if (entry.additional.has_value()) {
    this->output << separator << "..."
                 << mangle(this->prefix, entry.additional->pointer,
                           entry.additional->symbol, this->cache)
                 << "[]";
  }

  this->output << "];\n";
}

auto TypeScript::operator()(const IRUnion &entry) -> void {
  this->output << "export type "
               << mangle(this->prefix, entry.pointer, entry.symbol, this->cache)
               << " =\n";

  const char *separator{""};
  for (const auto &value : entry.values) {
    this->output << separator << "  "
                 << mangle(this->prefix, value.pointer, value.symbol,
                           this->cache);
    separator = " |\n";
  }

  this->output << ";\n";
}

auto TypeScript::operator()(const IRIntersection &entry) -> void {
  this->output << "export type "
               << mangle(this->prefix, entry.pointer, entry.symbol, this->cache)
               << " =\n";

  const char *separator{""};
  for (const auto &value : entry.values) {
    this->output << separator << "  "
                 << mangle(this->prefix, value.pointer, value.symbol,
                           this->cache);
    separator = " &\n";
  }

  this->output << ";\n";
}

auto TypeScript::operator()(const IRConditional &entry) -> void {
  // As a notable limitation, TypeScript cannot express the negation of an
  // if/then/else condition, so the else branch is wider than what JSON
  // Schema allows
  this->output << "// (if & then) | else approximation: the else branch is "
                  "wider than what\n";
  this->output << "// JSON Schema allows, as TypeScript cannot express type "
                  "negation\n";
  this->output << "export type "
               << mangle(this->prefix, entry.pointer, entry.symbol, this->cache)
               << " =\n  ("
               << mangle(this->prefix, entry.condition.pointer,
                         entry.condition.symbol, this->cache)
               << " & "
               << mangle(this->prefix, entry.consequent.pointer,
                         entry.consequent.symbol, this->cache)
               << ") | "
               << mangle(this->prefix, entry.alternative.pointer,
                         entry.alternative.symbol, this->cache)
               << ";\n";
}

} // namespace sourcemeta::codegen