@glimmer/syntax/dist/commonjs/es2017/lib/source/loc/offset.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.InvisiblePosition = exports.HbsPosition = exports.CharPosition = exports.SourceOffset = exports.BROKEN = void 0;

var _location = require("../location");

var _match = require("./match");

var _span = require("./span");

// eslint-disable-next-line import/no-extraneous-dependencies

/**
 * Used to indicate that an attempt to convert a `SourcePosition` to a character offset failed. It
 * is separate from `null` so that `null` can be used to indicate that the computation wasn't yet
 * attempted (and therefore to cache the failure)
 */
const BROKEN = 'BROKEN';
/**
 * A `SourceOffset` represents a single position in the source.
 *
 * There are three kinds of backing data for `SourceOffset` objects:
 *
 * - `CharPosition`, which contains a character offset into the raw source string
 * - `HbsPosition`, which contains a `SourcePosition` from the Handlebars AST, which can be
 *   converted to a `CharPosition` on demand.
 * - `InvisiblePosition`, which represents a position not in source (@see {InvisiblePosition})
 */

exports.BROKEN = BROKEN;

class SourceOffset {
  constructor(data) {
    this.data = data;
  }
  /**
   * Create a `SourceOffset` from a Handlebars `SourcePosition`. It's stored as-is, and converted
   * into a character offset on demand, which avoids unnecessarily computing the offset of every
   * `SourceLocation`, but also means that broken `SourcePosition`s are not always detected.
   */


  static forHbsPos(source, pos) {
    return new HbsPosition(source, pos, null).wrap();
  }
  /**
   * Create a `SourceOffset` that corresponds to a broken `SourcePosition`. This means that the
   * calling code determined (or knows) that the `SourceLocation` doesn't correspond correctly to
   * any part of the source.
   */


  static broken(pos = _location.UNKNOWN_POSITION) {
    return new InvisiblePosition("Broken"
    /* Broken */
    , pos).wrap();
  }
  /**
   * Get the character offset for this `SourceOffset`, if possible.
   */


  get offset() {
    let charPos = this.data.toCharPos();
    return charPos === null ? null : charPos.offset;
  }
  /**
   * Compare this offset with another one.
   *
   * If both offsets are `HbsPosition`s, they're equivalent as long as their lines and columns are
   * the same. This avoids computing offsets unnecessarily.
   *
   * Otherwise, two `SourceOffset`s are equivalent if their successfully computed character offsets
   * are the same.
   */


  eql(right) {
    return eql(this.data, right.data);
  }
  /**
   * Create a span that starts from this source offset and ends with another source offset. Avoid
   * computing character offsets if both `SourceOffset`s are still lazy.
   */


  until(other) {
    return (0, _span.span)(this.data, other.data);
  }
  /**
   * Create a `SourceOffset` by moving the character position represented by this source offset
   * forward or backward (if `by` is negative), if possible.
   *
   * If this `SourceOffset` can't compute a valid character offset, `move` returns a broken offset.
   *
   * If the resulting character offset is less than 0 or greater than the size of the source, `move`
   * returns a broken offset.
   */


  move(by) {
    let charPos = this.data.toCharPos();

    if (charPos === null) {
      return SourceOffset.broken();
    } else {
      let result = charPos.offset + by;

      if (charPos.source.check(result)) {
        return new CharPosition(charPos.source, result).wrap();
      } else {
        return SourceOffset.broken();
      }
    }
  }
  /**
   * Create a new `SourceSpan` that represents a collapsed range at this source offset. Avoid
   * computing the character offset if it has not already been computed.
   */


  collapsed() {
    return (0, _span.span)(this.data, this.data);
  }
  /**
   * Convert this `SourceOffset` into a Handlebars {@see SourcePosition} for compatibility with
   * existing plugins.
   */


  toJSON() {
    return this.data.toJSON();
  }

}

exports.SourceOffset = SourceOffset;

class CharPosition {
  constructor(source, charPos) {
    this.source = source;
    this.charPos = charPos;
    this.kind = "CharPosition"
    /* CharPosition */
    ;
    /** Computed from char offset */

    this._locPos = null;
  }
  /**
   * This is already a `CharPosition`.
   *
   * {@see HbsPosition} for the alternative.
   *
   * @implements {PositionData}
   */


  toCharPos() {
    return this;
  }
  /**
   * Produce a Handlebars {@see SourcePosition} for this `CharPosition`. If this `CharPosition` was
   * computed using {@see SourceOffset#move}, this will compute the `SourcePosition` for the offset.
   *
   * @implements {PositionData}
   */


  toJSON() {
    let hbs = this.toHbsPos();
    return hbs === null ? _location.UNKNOWN_POSITION : hbs.toJSON();
  }

  wrap() {
    return new SourceOffset(this);
  }
  /**
   * A `CharPosition` always has an offset it can produce without any additional computation.
   */


  get offset() {
    return this.charPos;
  }
  /**
   * Convert the current character offset to an `HbsPosition`, if it was not already computed. Once
   * a `CharPosition` has computed its `HbsPosition`, it will not need to do compute it again, and
   * the same `CharPosition` is retained when used as one of the ends of a `SourceSpan`, so
   * computing the `HbsPosition` should be a one-time operation.
   */


  toHbsPos() {
    let locPos = this._locPos;

    if (locPos === null) {
      let hbsPos = this.source.hbsPosFor(this.charPos);

      if (hbsPos === null) {
        this._locPos = locPos = BROKEN;
      } else {
        this._locPos = locPos = new HbsPosition(this.source, hbsPos, this.charPos);
      }
    }

    return locPos === BROKEN ? null : locPos;
  }

}

exports.CharPosition = CharPosition;

class HbsPosition {
  constructor(source, hbsPos, charPos = null) {
    this.source = source;
    this.hbsPos = hbsPos;
    this.kind = "HbsPosition"
    /* HbsPosition */
    ;
    this._charPos = charPos === null ? null : new CharPosition(source, charPos);
  }
  /**
   * Lazily compute the character offset from the {@see SourcePosition}. Once an `HbsPosition` has
   * computed its `CharPosition`, it will not need to do compute it again, and the same
   * `HbsPosition` is retained when used as one of the ends of a `SourceSpan`, so computing the
   * `CharPosition` should be a one-time operation.
   *
   * @implements {PositionData}
   */


  toCharPos() {
    let charPos = this._charPos;

    if (charPos === null) {
      let charPosNumber = this.source.charPosFor(this.hbsPos);

      if (charPosNumber === null) {
        this._charPos = charPos = BROKEN;
      } else {
        this._charPos = charPos = new CharPosition(this.source, charPosNumber);
      }
    }

    return charPos === BROKEN ? null : charPos;
  }
  /**
   * Return the {@see SourcePosition} that this `HbsPosition` was instantiated with. This operation
   * does not need to compute anything.
   *
   * @implements {PositionData}
   */


  toJSON() {
    return this.hbsPos;
  }

  wrap() {
    return new SourceOffset(this);
  }
  /**
   * This is already an `HbsPosition`.
   *
   * {@see CharPosition} for the alternative.
   */


  toHbsPos() {
    return this;
  }

}

exports.HbsPosition = HbsPosition;

class InvisiblePosition {
  constructor(kind, // whatever was provided, possibly broken
  pos) {
    this.kind = kind;
    this.pos = pos;
  }
  /**
   * A broken position cannot be turned into a {@see CharacterPosition}.
   */


  toCharPos() {
    return null;
  }
  /**
   * The serialization of an `InvisiblePosition is whatever Handlebars {@see SourcePosition} was
   * originally identified as broken, non-existent or synthetic.
   *
   * If an `InvisiblePosition` never had an source offset at all, this method returns
   * {@see UNKNOWN_POSITION} for compatibility.
   */


  toJSON() {
    return this.pos;
  }

  wrap() {
    return new SourceOffset(this);
  }

  get offset() {
    return null;
  }

}
/**
 * Compare two {@see AnyPosition} and determine whether they are equal.
 *
 * @see {SourceOffset#eql}
 */


exports.InvisiblePosition = InvisiblePosition;
const eql = (0, _match.match)(m => m.when("HbsPosition"
/* HbsPosition */
, "HbsPosition"
/* HbsPosition */
, ({
  hbsPos: left
}, {
  hbsPos: right
}) => left.column === right.column && left.line === right.line).when("CharPosition"
/* CharPosition */
, "CharPosition"
/* CharPosition */
, ({
  charPos: left
}, {
  charPos: right
}) => left === right).when("CharPosition"
/* CharPosition */
, "HbsPosition"
/* HbsPosition */
, ({
  offset: left
}, right) => {
  var _a;

  return left === ((_a = right.toCharPos()) === null || _a === void 0 ? void 0 : _a.offset);
}).when("HbsPosition"
/* HbsPosition */
, "CharPosition"
/* CharPosition */
, (left, {
  offset: right
}) => {
  var _a;

  return ((_a = left.toCharPos()) === null || _a === void 0 ? void 0 : _a.offset) === right;
}).when(_match.MatchAny, _match.MatchAny, () => false));
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../../packages/@glimmer/syntax/lib/source/loc/offset.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line import/no-extraneous-dependencies\nimport { SourcePosition, UNKNOWN_POSITION } from '../location';\nimport { Source } from '../source';\nimport { match, MatchAny } from './match';\nimport { SourceSpan, span } from './span';\n\nexport const enum OffsetKind {\n  /**\n   * We have already computed the character position of this offset or span.\n   */\n  CharPosition = 'CharPosition',\n\n  /**\n   * This offset or span was instantiated with a Handlebars SourcePosition or SourceLocation. Its\n   * character position will be computed on demand.\n   */\n  HbsPosition = 'HbsPosition',\n\n  /**\n   * for (rare) situations where a node is created but there was no source location (e.g. the name\n   * \"default\" in default blocks when the word \"default\" never appeared in source). This is used\n   * by the internals when there is a legitimate reason for the internals to synthesize a node\n   * with no location.\n   */\n  InternalsSynthetic = 'InternalsSynthetic',\n  /**\n   * For situations where a node represents zero parts of the source (for example, empty arguments).\n   * In general, we attempt to assign these nodes *some* position (empty arguments can be\n   * positioned immediately after the callee), but it's not always possible\n   */\n  NonExistent = 'NonExistent',\n  /**\n   * For situations where a source location was expected, but it didn't correspond to the node in\n   * the source. This happens if a plugin creates broken locations.\n   */\n  Broken = 'Broken',\n}\n\n/**\n * All positions have these details in common. Most notably, all three kinds of positions can\n * must be able to attempt to convert themselves into {@see CharPosition}.\n */\nexport interface PositionData {\n  readonly kind: OffsetKind;\n  toCharPos(): CharPosition | null;\n  toJSON(): SourcePosition;\n}\n\n/**\n * Used to indicate that an attempt to convert a `SourcePosition` to a character offset failed. It\n * is separate from `null` so that `null` can be used to indicate that the computation wasn't yet\n * attempted (and therefore to cache the failure)\n */\nexport const BROKEN = 'BROKEN';\nexport type BROKEN = 'BROKEN';\n\nexport type AnyPosition = HbsPosition | CharPosition | InvisiblePosition;\n\n/**\n * A `SourceOffset` represents a single position in the source.\n *\n * There are three kinds of backing data for `SourceOffset` objects:\n *\n * - `CharPosition`, which contains a character offset into the raw source string\n * - `HbsPosition`, which contains a `SourcePosition` from the Handlebars AST, which can be\n *   converted to a `CharPosition` on demand.\n * - `InvisiblePosition`, which represents a position not in source (@see {InvisiblePosition})\n */\nexport class SourceOffset {\n  /**\n   * Create a `SourceOffset` from a Handlebars `SourcePosition`. It's stored as-is, and converted\n   * into a character offset on demand, which avoids unnecessarily computing the offset of every\n   * `SourceLocation`, but also means that broken `SourcePosition`s are not always detected.\n   */\n  static forHbsPos(source: Source, pos: SourcePosition): SourceOffset {\n    return new HbsPosition(source, pos, null).wrap();\n  }\n\n  /**\n   * Create a `SourceOffset` that corresponds to a broken `SourcePosition`. This means that the\n   * calling code determined (or knows) that the `SourceLocation` doesn't correspond correctly to\n   * any part of the source.\n   */\n  static broken(pos: SourcePosition = UNKNOWN_POSITION): SourceOffset {\n    return new InvisiblePosition(OffsetKind.Broken, pos).wrap();\n  }\n\n  constructor(readonly data: PositionData & AnyPosition) {}\n\n  /**\n   * Get the character offset for this `SourceOffset`, if possible.\n   */\n  get offset(): number | null {\n    let charPos = this.data.toCharPos();\n    return charPos === null ? null : charPos.offset;\n  }\n\n  /**\n   * Compare this offset with another one.\n   *\n   * If both offsets are `HbsPosition`s, they're equivalent as long as their lines and columns are\n   * the same. This avoids computing offsets unnecessarily.\n   *\n   * Otherwise, two `SourceOffset`s are equivalent if their successfully computed character offsets\n   * are the same.\n   */\n  eql(right: SourceOffset): boolean {\n    return eql(this.data, right.data);\n  }\n\n  /**\n   * Create a span that starts from this source offset and ends with another source offset. Avoid\n   * computing character offsets if both `SourceOffset`s are still lazy.\n   */\n  until(other: SourceOffset): SourceSpan {\n    return span(this.data, other.data);\n  }\n\n  /**\n   * Create a `SourceOffset` by moving the character position represented by this source offset\n   * forward or backward (if `by` is negative), if possible.\n   *\n   * If this `SourceOffset` can't compute a valid character offset, `move` returns a broken offset.\n   *\n   * If the resulting character offset is less than 0 or greater than the size of the source, `move`\n   * returns a broken offset.\n   */\n  move(by: number): SourceOffset {\n    let charPos = this.data.toCharPos();\n\n    if (charPos === null) {\n      return SourceOffset.broken();\n    } else {\n      let result = charPos.offset + by;\n\n      if (charPos.source.check(result)) {\n        return new CharPosition(charPos.source, result).wrap();\n      } else {\n        return SourceOffset.broken();\n      }\n    }\n  }\n\n  /**\n   * Create a new `SourceSpan` that represents a collapsed range at this source offset. Avoid\n   * computing the character offset if it has not already been computed.\n   */\n  collapsed(): SourceSpan {\n    return span(this.data, this.data);\n  }\n\n  /**\n   * Convert this `SourceOffset` into a Handlebars {@see SourcePosition} for compatibility with\n   * existing plugins.\n   */\n  toJSON(): SourcePosition {\n    return this.data.toJSON();\n  }\n}\n\nexport class CharPosition implements PositionData {\n  readonly kind = OffsetKind.CharPosition;\n\n  /** Computed from char offset */\n  _locPos: HbsPosition | BROKEN | null = null;\n\n  constructor(readonly source: Source, readonly charPos: number) {}\n\n  /**\n   * This is already a `CharPosition`.\n   *\n   * {@see HbsPosition} for the alternative.\n   *\n   * @implements {PositionData}\n   */\n  toCharPos(): CharPosition {\n    return this;\n  }\n\n  /**\n   * Produce a Handlebars {@see SourcePosition} for this `CharPosition`. If this `CharPosition` was\n   * computed using {@see SourceOffset#move}, this will compute the `SourcePosition` for the offset.\n   *\n   * @implements {PositionData}\n   */\n  toJSON(): SourcePosition {\n    let hbs = this.toHbsPos();\n    return hbs === null ? UNKNOWN_POSITION : hbs.toJSON();\n  }\n\n  wrap(): SourceOffset {\n    return new SourceOffset(this);\n  }\n\n  /**\n   * A `CharPosition` always has an offset it can produce without any additional computation.\n   */\n  get offset(): number {\n    return this.charPos;\n  }\n\n  /**\n   * Convert the current character offset to an `HbsPosition`, if it was not already computed. Once\n   * a `CharPosition` has computed its `HbsPosition`, it will not need to do compute it again, and\n   * the same `CharPosition` is retained when used as one of the ends of a `SourceSpan`, so\n   * computing the `HbsPosition` should be a one-time operation.\n   */\n  toHbsPos(): HbsPosition | null {\n    let locPos = this._locPos;\n\n    if (locPos === null) {\n      let hbsPos = this.source.hbsPosFor(this.charPos);\n\n      if (hbsPos === null) {\n        this._locPos = locPos = BROKEN;\n      } else {\n        this._locPos = locPos = new HbsPosition(this.source, hbsPos, this.charPos);\n      }\n    }\n\n    return locPos === BROKEN ? null : locPos;\n  }\n}\n\nexport class HbsPosition implements PositionData {\n  readonly kind = OffsetKind.HbsPosition;\n\n  _charPos: CharPosition | BROKEN | null;\n\n  constructor(\n    readonly source: Source,\n    readonly hbsPos: SourcePosition,\n    charPos: number | null = null\n  ) {\n    this._charPos = charPos === null ? null : new CharPosition(source, charPos);\n  }\n\n  /**\n   * Lazily compute the character offset from the {@see SourcePosition}. Once an `HbsPosition` has\n   * computed its `CharPosition`, it will not need to do compute it again, and the same\n   * `HbsPosition` is retained when used as one of the ends of a `SourceSpan`, so computing the\n   * `CharPosition` should be a one-time operation.\n   *\n   * @implements {PositionData}\n   */\n  toCharPos(): CharPosition | null {\n    let charPos = this._charPos;\n\n    if (charPos === null) {\n      let charPosNumber = this.source.charPosFor(this.hbsPos);\n\n      if (charPosNumber === null) {\n        this._charPos = charPos = BROKEN;\n      } else {\n        this._charPos = charPos = new CharPosition(this.source, charPosNumber);\n      }\n    }\n\n    return charPos === BROKEN ? null : charPos;\n  }\n\n  /**\n   * Return the {@see SourcePosition} that this `HbsPosition` was instantiated with. This operation\n   * does not need to compute anything.\n   *\n   * @implements {PositionData}\n   */\n  toJSON(): SourcePosition {\n    return this.hbsPos;\n  }\n\n  wrap(): SourceOffset {\n    return new SourceOffset(this);\n  }\n\n  /**\n   * This is already an `HbsPosition`.\n   *\n   * {@see CharPosition} for the alternative.\n   */\n  toHbsPos(): HbsPosition {\n    return this;\n  }\n}\n\nexport class InvisiblePosition implements PositionData {\n  constructor(\n    readonly kind: OffsetKind.Broken | OffsetKind.InternalsSynthetic | OffsetKind.NonExistent,\n    // whatever was provided, possibly broken\n    readonly pos: SourcePosition\n  ) {}\n\n  /**\n   * A broken position cannot be turned into a {@see CharacterPosition}.\n   */\n  toCharPos(): null {\n    return null;\n  }\n\n  /**\n   * The serialization of an `InvisiblePosition is whatever Handlebars {@see SourcePosition} was\n   * originally identified as broken, non-existent or synthetic.\n   *\n   * If an `InvisiblePosition` never had an source offset at all, this method returns\n   * {@see UNKNOWN_POSITION} for compatibility.\n   */\n  toJSON(): SourcePosition {\n    return this.pos;\n  }\n\n  wrap(): SourceOffset {\n    return new SourceOffset(this);\n  }\n\n  get offset(): null {\n    return null;\n  }\n}\n\n/**\n * Compare two {@see AnyPosition} and determine whether they are equal.\n *\n * @see {SourceOffset#eql}\n */\nconst eql = match<boolean>((m) =>\n  m\n    .when(\n      OffsetKind.HbsPosition,\n      OffsetKind.HbsPosition,\n      ({ hbsPos: left }, { hbsPos: right }) =>\n        left.column === right.column && left.line === right.line\n    )\n    .when(\n      OffsetKind.CharPosition,\n      OffsetKind.CharPosition,\n      ({ charPos: left }, { charPos: right }) => left === right\n    )\n    .when(\n      OffsetKind.CharPosition,\n      OffsetKind.HbsPosition,\n      ({ offset: left }, right) => left === right.toCharPos()?.offset\n    )\n    .when(\n      OffsetKind.HbsPosition,\n      OffsetKind.CharPosition,\n      (left, { offset: right }) => left.toCharPos()?.offset === right\n    )\n    .when(MatchAny, MatchAny, () => false)\n);\n"],"sourceRoot":""}