alinea/dist/core/Hint.js

[](https://npmjs.org/package/alinea) [](https://packagephobia.com/result?p=alinea)

import "../chunks/chunk-U5RRZUYZ.js";

// src/core/Hint.ts
import { Lazy } from "./util/Lazy.js";
var { entries, keys, values } = Object;
var Hint;
((Hint2) => {
  function String() {
    return { type: "string" };
  }
  Hint2.String = String;
  function Number() {
    return { type: "number" };
  }
  Hint2.Number = Number;
  function Boolean() {
    return { type: "boolean" };
  }
  Hint2.Boolean = Boolean;
  function Literal(value) {
    return { type: "literal", value };
  }
  Hint2.Literal = Literal;
  function Array(inner) {
    return { type: "array", inner };
  }
  Hint2.Array = Array;
  function Definition(name, fields, ...extend) {
    return { type: "definition", name, fields, extend };
  }
  Hint2.Definition = Definition;
  function Object2(fields) {
    return { type: "object", fields };
  }
  Hint2.Object = Object2;
  function Union(options) {
    return { type: "union", options };
  }
  Hint2.Union = Union;
  function Intersection(...options) {
    return { type: "intersection", options };
  }
  Hint2.Intersection = Intersection;
  function Extern(from, ...typeParams) {
    return { type: "extern", from, typeParams };
  }
  Hint2.Extern = Extern;
  const validIdentifier = /^[_A-Za-z][_0-9A-Za-z]*$/;
  function isValidIdentifier(identifier) {
    return validIdentifier.test(identifier);
  }
  Hint2.isValidIdentifier = isValidIdentifier;
  function isDefinitionName(identifier) {
    return identifier.charAt(0).toUpperCase() === identifier[0];
  }
  Hint2.isDefinitionName = isDefinitionName;
  function externs(hints, map = /* @__PURE__ */ new Map()) {
    for (const hint of hints)
      switch (hint.type) {
        case "array":
          externs([hint.inner], map);
          continue;
        case "definition":
          const fields = Lazy.get(hint.fields);
          externs(values(fields).concat(hint.extend), map);
          continue;
        case "object":
          externs(values(hint.fields), map);
          continue;
        case "intersection":
        case "union":
          externs(hint.options, map);
          continue;
        case "extern":
          if (map.has(hint.from.package)) {
            map.get(hint.from.package).add(hint.from.name);
          } else {
            map.set(hint.from.package, /* @__PURE__ */ new Set([hint.from.name]));
          }
          externs(hint.typeParams, map);
          continue;
      }
    return map;
  }
  Hint2.externs = externs;
  function* definitions(hints, parents = []) {
    for (const hint of hints)
      switch (hint.type) {
        case "array":
          yield* definitions([hint.inner], parents);
          break;
        case "definition":
          const fields = Lazy.get(hint.fields);
          for (const [name, inner] of entries(fields))
            yield* definitions([inner], parents.concat(hint.name, name));
          yield* definitions(hint.extend, parents.concat(hint.name));
          yield { ...hint, parents };
          continue;
        case "object":
          for (const [name, inner] of entries(hint.fields))
            yield* definitions([inner], parents.concat(name));
          continue;
        case "intersection":
        case "union":
          yield* definitions(hint.options, parents);
          continue;
        case "extern":
          yield* definitions(hint.typeParams, parents);
          continue;
      }
  }
  Hint2.definitions = definitions;
  function equals(a, b) {
    if (a.type !== b.type)
      return false;
    switch (a.type) {
      case "string":
      case "number":
      case "boolean":
        return true;
      case "array":
        const bArray = b;
        return equals(a.inner, bArray.inner);
      case "literal":
        const bLiteral = b;
        return a.value === bLiteral.value;
      case "definition":
        const bDefinition = b;
        const aFields = Lazy.get(a.fields), bFields = Lazy.get(bDefinition.fields);
        return a.name === bDefinition.name && keys(aFields).length === keys(bFields).length && keys(aFields).every((key) => {
          return equals(aFields[key], bFields[key]);
        });
      case "object":
        const bRecord = b;
        return keys(a.fields).length === keys(bRecord.fields).length && keys(a.fields).every((key) => {
          return equals(a.fields[key], bRecord.fields[key]);
        });
      case "intersection":
      case "union":
        const bUnion = b;
        return a.options.every((option, i) => {
          return equals(option, bUnion.options[i]);
        });
      case "extern":
        const bExtern = b;
        return a.from.name === bExtern.from.name && a.from.package === bExtern.from.package && a.typeParams.every((param, i) => equals(param, bExtern.typeParams[i]));
    }
  }
  Hint2.equals = equals;
})(Hint || (Hint = {}));
export {
  Hint
};