Class Construct

src/construct.ts:530–598

 * another construct.
 */
export class Construct implements IConstruct {
  /**
   * Checks if `x` is a construct.
   *
   * Use this method instead of `instanceof` to properly detect `Construct`
   * instances, even when the construct library is symlinked.
   *
   * Explanation: in JavaScript, multiple copies of the `constructs` library on
   * disk are seen as independent, completely different libraries. As a
   * consequence, the class `Construct` in each copy of the `constructs` library
   * is seen as a different class, and an instance of one class will not test as
   * `instanceof` the other class. `npm install` will not create installations
   * like this, but users may manually symlink construct libraries together or
   * use a monorepo tool: in those cases, multiple copies of the `constructs`
   * library can be accidentally installed, and `instanceof` will behave
   * unpredictably. It is safest to avoid using `instanceof`, and using
   * this type-testing method instead.
   *
   * @returns true if `x` is an object created from a class which extends `Construct`.
   * @param x Any object
   */
  public static isConstruct(x: any): x is Construct {
    return x && typeof x === 'object' && x[CONSTRUCT_SYM];
  }

  /**
   * The tree node.
   */
  public readonly node: Node;

  /**
   * Creates a new construct node.
   *
   * @param scope The scope in which to define this construct
   * @param id The scoped construct ID. Must be unique amongst siblings. If
   * the ID includes a path separator (`/`), then it will be replaced by double
   * dash `--`.
   */
  constructor(scope: Construct, id: string) {
    this.node = new Node(this, scope, id);

    // implement IDependable privately
    Dependable.implement(this, {
      dependencyRoots: [this],
    });
  }

  /**
   * Applies one or more mixins to this construct.
   *
   * Mixins are applied in order. The list of constructs is captured at the
   * start of the call, so constructs added by a mixin will not be visited.
   * Use multiple `with()` calls if subsequent mixins should apply to added
   * constructs.
   *
   * @param mixins The mixins to apply
   * @returns This construct for chaining
   */