terraconstructs 0.0.8

package/lib/duration.js

@@ -0,0 +1,327 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Duration = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.154.1/packages/aws-cdk-lib/core/lib/duration.ts
+const cdktf_1 = require("cdktf");
+/**
+ * Represents a length of time.
+ *
+ * The amount can be specified either as a literal value (e.g: `10`) which
+ * cannot be negative, or as an unresolved number token.
+ *
+ * When the amount is passed as a token, unit conversion is not possible.
+ */
+class Duration {
+    /**
+     * Create a Duration representing an amount of milliseconds
+     *
+     * @param amount the amount of Milliseconds the `Duration` will represent.
+     * @returns a new `Duration` representing `amount` ms.
+     */
+    static millis(amount) {
+        return new Duration(amount, TimeUnit.Milliseconds);
+    }
+    /**
+     * Create a Duration representing an amount of seconds
+     *
+     * @param amount the amount of Seconds the `Duration` will represent.
+     * @returns a new `Duration` representing `amount` Seconds.
+     */
+    static seconds(amount) {
+        return new Duration(amount, TimeUnit.Seconds);
+    }
+    /**
+     * Create a Duration representing an amount of minutes
+     *
+     * @param amount the amount of Minutes the `Duration` will represent.
+     * @returns a new `Duration` representing `amount` Minutes.
+     */
+    static minutes(amount) {
+        return new Duration(amount, TimeUnit.Minutes);
+    }
+    /**
+     * Create a Duration representing an amount of hours
+     *
+     * @param amount the amount of Hours the `Duration` will represent.
+     * @returns a new `Duration` representing `amount` Hours.
+     */
+    static hours(amount) {
+        return new Duration(amount, TimeUnit.Hours);
+    }
+    /**
+     * Create a Duration representing an amount of days
+     *
+     * @param amount the amount of Days the `Duration` will represent.
+     * @returns a new `Duration` representing `amount` Days.
+     */
+    static days(amount) {
+        return new Duration(amount, TimeUnit.Days);
+    }
+    /**
+     * Parse a period formatted according to the ISO 8601 standard
+     *
+     * Days are the largest ISO duration supported, i.e.,
+     * weeks, months, and years are not supported.
+     *
+     * @example
+     * // This represents 1 day, 2 hours, 3 minutes, 4 seconds, and 567 milliseconds.
+     * 'P1DT2H3M4.567S'
+     *
+     * @see https://www.iso.org/standard/70907.html
+     * @param duration an ISO-formatted duration to be parsed.
+     * @returns the parsed `Duration`.
+     */
+    static parse(duration) {
+        const matches = duration.match(/^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)\.?(\d{1,3})?S)?)?$/);
+        if (!matches) {
+            throw new Error(`Not a valid ISO duration: ${duration}`);
+        }
+        const [, days, hours, minutes, seconds, milliseconds] = matches;
+        if (!days && !hours && !minutes && !seconds && !milliseconds) {
+            throw new Error(`Not a valid ISO duration: ${duration}`);
+        }
+        const millis = milliseconds ? milliseconds.padEnd(3, "0") : "";
+        return Duration.millis(_toInt(millis) +
+            _toInt(seconds) * TimeUnit.Seconds.inMillis +
+            _toInt(minutes) * TimeUnit.Minutes.inMillis +
+            _toInt(hours) * TimeUnit.Hours.inMillis +
+            _toInt(days) * TimeUnit.Days.inMillis);
+        function _toInt(str) {
+            if (!str) {
+                return 0;
+            }
+            return Number(str);
+        }
+    }
+    constructor(amount, unit) {
+        if (!cdktf_1.Token.isUnresolved(amount) && amount < 0) {
+            throw new Error(`Duration amounts cannot be negative. Received: ${amount}`);
+        }
+        this.amount = amount;
+        this.unit = unit;
+    }
+    /**
+     * Add two Durations together
+     */
+    plus(rhs) {
+        const targetUnit = finestUnit(this.unit, rhs.unit);
+        const res = convert(this.amount, this.unit, targetUnit, {}) +
+            convert(rhs.amount, rhs.unit, targetUnit, {});
+        return new Duration(res, targetUnit);
+    }
+    /**
+     * Substract two Durations together
+     */
+    minus(rhs) {
+        const targetUnit = finestUnit(this.unit, rhs.unit);
+        const res = convert(this.amount, this.unit, targetUnit, {}) -
+            convert(rhs.amount, rhs.unit, targetUnit, {});
+        return new Duration(res, targetUnit);
+    }
+    /**
+     * Return the total number of milliseconds in this Duration
+     *
+     * @returns the value of this `Duration` expressed in Milliseconds.
+     */
+    toMilliseconds(opts = {}) {
+        return convert(this.amount, this.unit, TimeUnit.Milliseconds, opts);
+    }
+    /**
+     * Return the total number of seconds in this Duration
+     *
+     * @returns the value of this `Duration` expressed in Seconds.
+     */
+    toSeconds(opts = {}) {
+        return convert(this.amount, this.unit, TimeUnit.Seconds, opts);
+    }
+    /**
+     * Return the total number of minutes in this Duration
+     *
+     * @returns the value of this `Duration` expressed in Minutes.
+     */
+    toMinutes(opts = {}) {
+        return convert(this.amount, this.unit, TimeUnit.Minutes, opts);
+    }
+    /**
+     * Return the total number of hours in this Duration
+     *
+     * @returns the value of this `Duration` expressed in Hours.
+     */
+    toHours(opts = {}) {
+        return convert(this.amount, this.unit, TimeUnit.Hours, opts);
+    }
+    /**
+     * Return the total number of days in this Duration
+     *
+     * @returns the value of this `Duration` expressed in Days.
+     */
+    toDays(opts = {}) {
+        return convert(this.amount, this.unit, TimeUnit.Days, opts);
+    }
+    /**
+     * Return an ISO 8601 representation of this period
+     *
+     * @returns a string starting with 'P' describing the period
+     * @see https://www.iso.org/standard/70907.html
+     */
+    toIsoString() {
+        if (this.amount === 0) {
+            return "PT0S";
+        }
+        const ret = ["P"];
+        let tee = false;
+        for (const [amount, unit] of this.components(true)) {
+            if ([TimeUnit.Seconds, TimeUnit.Minutes, TimeUnit.Hours].includes(unit) &&
+                !tee) {
+                ret.push("T");
+                tee = true;
+            }
+            ret.push(`${amount}${unit.isoLabel}`);
+        }
+        return ret.join("");
+    }
+    /**
+     * Return an ISO 8601 representation of this period
+     *
+     * @returns a string starting with 'P' describing the period
+     * @see https://www.iso.org/standard/70907.html
+     * @deprecated Use `toIsoString()` instead.
+     */
+    toISOString() {
+        return this.toIsoString();
+    }
+    /**
+     * Turn this duration into a human-readable string
+     */
+    toHumanString() {
+        if (this.amount === 0) {
+            return fmtUnit(0, this.unit);
+        }
+        if (cdktf_1.Token.isUnresolved(this.amount)) {
+            return `<token> ${this.unit.label}`;
+        }
+        return (this.components(false)
+            // 2 significant parts, that's totally enough for humans
+            .slice(0, 2)
+            .map(([amount, unit]) => fmtUnit(amount, unit))
+            .join(" "));
+        function fmtUnit(amount, unit) {
+            if (amount === 1) {
+                // All of the labels end in 's'
+                return `${amount} ${unit.label.substring(0, unit.label.length - 1)}`;
+            }
+            return `${amount} ${unit.label}`;
+        }
+    }
+    /**
+     * Returns a string representation of this `Duration`
+     *
+     * This is is never the right function to use when you want to use the `Duration`
+     * object in a template. Use `toSeconds()`, `toMinutes()`, `toDays()`, etc. instead.
+     */
+    toString() {
+        return `Duration.${this.unit.label}(${this.amount})`;
+    }
+    /**
+     * Return the duration in a set of whole numbered time components, ordered from largest to smallest
+     *
+     * Only components != 0 will be returned.
+     *
+     * Can combine millis and seconds together for the benefit of toIsoString,
+     * makes the logic in there simpler.
+     */
+    components(combineMillisWithSeconds) {
+        const ret = new Array();
+        let millis = convert(this.amount, this.unit, TimeUnit.Milliseconds, {
+            integral: false,
+        });
+        for (const unit of [
+            TimeUnit.Days,
+            TimeUnit.Hours,
+            TimeUnit.Minutes,
+            TimeUnit.Seconds,
+        ]) {
+            const count = convert(millis, TimeUnit.Milliseconds, unit, {
+                integral: false,
+            });
+            // Round down to a whole number UNLESS we're combining millis and seconds and we got to the seconds
+            const wholeCount = unit === TimeUnit.Seconds && combineMillisWithSeconds
+                ? count
+                : Math.floor(count);
+            if (wholeCount > 0) {
+                ret.push([wholeCount, unit]);
+                millis -= wholeCount * unit.inMillis;
+            }
+        }
+        // Remainder in millis (keep only above threshold)
+        if (millis > 0.0001) {
+            ret.push([millis, TimeUnit.Milliseconds]);
+        }
+        return ret;
+    }
+    /**
+     * Checks if duration is a token or a resolvable object
+     */
+    isUnresolved() {
+        return cdktf_1.Token.isUnresolved(this.amount);
+    }
+    /**
+     * Returns unit of the duration
+     */
+    unitLabel() {
+        return this.unit.label;
+    }
+    /**
+     * Returns stringified number of duration
+     */
+    formatTokenToNumber() {
+        const number = cdktf_1.Tokenization.stringifyNumber(this.amount);
+        return `${number} ${this.unit.label}`;
+    }
+}
+exports.Duration = Duration;
+_a = JSII_RTTI_SYMBOL_1;
+Duration[_a] = { fqn: "terraconstructs.Duration", version: "0.0.8" };
+class TimeUnit {
+    constructor(label, isoLabel, inMillis) {
+        this.label = label;
+        this.isoLabel = isoLabel;
+        this.inMillis = inMillis;
+        // MAX_SAFE_INTEGER is 2^53, so by representing our duration in millis (the lowest
+        // common unit) the highest duration we can represent is
+        // 2^53 / 86*10^6 ~= 104 * 10^6 days (about 100 million days).
+    }
+    toString() {
+        return this.label;
+    }
+}
+TimeUnit.Milliseconds = new TimeUnit("millis", "", 1);
+TimeUnit.Seconds = new TimeUnit("seconds", "S", 1000);
+TimeUnit.Minutes = new TimeUnit("minutes", "M", 60000);
+TimeUnit.Hours = new TimeUnit("hours", "H", 3600000);
+TimeUnit.Days = new TimeUnit("days", "D", 86400000);
+function convert(amount, fromUnit, toUnit, { integral = true }) {
+    if (fromUnit.inMillis === toUnit.inMillis) {
+        if (integral && !cdktf_1.Token.isUnresolved(amount) && !Number.isInteger(amount)) {
+            throw new Error(`${amount} must be a whole number of ${toUnit}.`);
+        }
+        return amount;
+    }
+    if (cdktf_1.Token.isUnresolved(amount)) {
+        throw new Error(`Duration must be specified as 'Duration.${toUnit}()' here since its value comes from a token and cannot be converted (got Duration.${fromUnit})`);
+    }
+    const value = (amount * fromUnit.inMillis) / toUnit.inMillis;
+    if (!Number.isInteger(value) && integral) {
+        throw new Error(`'${amount} ${fromUnit}' cannot be converted into a whole number of ${toUnit}.`);
+    }
+    return value;
+}
+/**
+ * Return the time unit with highest granularity
+ */
+function finestUnit(a, b) {
+    return a.inMillis < b.inMillis ? a : b;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"duration.js","sourceRoot":"","sources":["../src/duration.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.154.1/packages/aws-cdk-lib/core/lib/duration.ts\nimport { Token, Tokenization } from \"cdktf\";\n\n/**\n * Represents a length of time.\n *\n * The amount can be specified either as a literal value (e.g: `10`) which\n * cannot be negative, or as an unresolved number token.\n *\n * When the amount is passed as a token, unit conversion is not possible.\n */\nexport class Duration {\n  /**\n   * Create a Duration representing an amount of milliseconds\n   *\n   * @param amount the amount of Milliseconds the `Duration` will represent.\n   * @returns a new `Duration` representing `amount` ms.\n   */\n  public static millis(amount: number): Duration {\n    return new Duration(amount, TimeUnit.Milliseconds);\n  }\n\n  /**\n   * Create a Duration representing an amount of seconds\n   *\n   * @param amount the amount of Seconds the `Duration` will represent.\n   * @returns a new `Duration` representing `amount` Seconds.\n   */\n  public static seconds(amount: number): Duration {\n    return new Duration(amount, TimeUnit.Seconds);\n  }\n\n  /**\n   * Create a Duration representing an amount of minutes\n   *\n   * @param amount the amount of Minutes the `Duration` will represent.\n   * @returns a new `Duration` representing `amount` Minutes.\n   */\n  public static minutes(amount: number): Duration {\n    return new Duration(amount, TimeUnit.Minutes);\n  }\n\n  /**\n   * Create a Duration representing an amount of hours\n   *\n   * @param amount the amount of Hours the `Duration` will represent.\n   * @returns a new `Duration` representing `amount` Hours.\n   */\n  public static hours(amount: number): Duration {\n    return new Duration(amount, TimeUnit.Hours);\n  }\n\n  /**\n   * Create a Duration representing an amount of days\n   *\n   * @param amount the amount of Days the `Duration` will represent.\n   * @returns a new `Duration` representing `amount` Days.\n   */\n  public static days(amount: number): Duration {\n    return new Duration(amount, TimeUnit.Days);\n  }\n\n  /**\n   * Parse a period formatted according to the ISO 8601 standard\n   *\n   * Days are the largest ISO duration supported, i.e.,\n   * weeks, months, and years are not supported.\n   *\n   * @example\n   * // This represents 1 day, 2 hours, 3 minutes, 4 seconds, and 567 milliseconds.\n   * 'P1DT2H3M4.567S'\n   *\n   * @see https://www.iso.org/standard/70907.html\n   * @param duration an ISO-formatted duration to be parsed.\n   * @returns the parsed `Duration`.\n   */\n  public static parse(duration: string): Duration {\n    const matches = duration.match(\n      /^P(?:(\\d+)D)?(?:T(?:(\\d+)H)?(?:(\\d+)M)?(?:(\\d+)\\.?(\\d{1,3})?S)?)?$/,\n    );\n    if (!matches) {\n      throw new Error(`Not a valid ISO duration: ${duration}`);\n    }\n    const [, days, hours, minutes, seconds, milliseconds] = matches;\n    if (!days && !hours && !minutes && !seconds && !milliseconds) {\n      throw new Error(`Not a valid ISO duration: ${duration}`);\n    }\n    const millis = milliseconds ? milliseconds.padEnd(3, \"0\") : \"\";\n    return Duration.millis(\n      _toInt(millis) +\n        _toInt(seconds) * TimeUnit.Seconds.inMillis +\n        _toInt(minutes) * TimeUnit.Minutes.inMillis +\n        _toInt(hours) * TimeUnit.Hours.inMillis +\n        _toInt(days) * TimeUnit.Days.inMillis,\n    );\n\n    function _toInt(str: string): number {\n      if (!str) {\n        return 0;\n      }\n      return Number(str);\n    }\n  }\n\n  private readonly amount: number;\n  private readonly unit: TimeUnit;\n\n  private constructor(amount: number, unit: TimeUnit) {\n    if (!Token.isUnresolved(amount) && amount < 0) {\n      throw new Error(\n        `Duration amounts cannot be negative. Received: ${amount}`,\n      );\n    }\n\n    this.amount = amount;\n    this.unit = unit;\n  }\n\n  /**\n   * Add two Durations together\n   */\n  public plus(rhs: Duration): Duration {\n    const targetUnit = finestUnit(this.unit, rhs.unit);\n    const res =\n      convert(this.amount, this.unit, targetUnit, {}) +\n      convert(rhs.amount, rhs.unit, targetUnit, {});\n    return new Duration(res, targetUnit);\n  }\n\n  /**\n   * Substract two Durations together\n   */\n  public minus(rhs: Duration): Duration {\n    const targetUnit = finestUnit(this.unit, rhs.unit);\n    const res =\n      convert(this.amount, this.unit, targetUnit, {}) -\n      convert(rhs.amount, rhs.unit, targetUnit, {});\n    return new Duration(res, targetUnit);\n  }\n\n  /**\n   * Return the total number of milliseconds in this Duration\n   *\n   * @returns the value of this `Duration` expressed in Milliseconds.\n   */\n  public toMilliseconds(opts: TimeConversionOptions = {}): number {\n    return convert(this.amount, this.unit, TimeUnit.Milliseconds, opts);\n  }\n\n  /**\n   * Return the total number of seconds in this Duration\n   *\n   * @returns the value of this `Duration` expressed in Seconds.\n   */\n  public toSeconds(opts: TimeConversionOptions = {}): number {\n    return convert(this.amount, this.unit, TimeUnit.Seconds, opts);\n  }\n\n  /**\n   * Return the total number of minutes in this Duration\n   *\n   * @returns the value of this `Duration` expressed in Minutes.\n   */\n  public toMinutes(opts: TimeConversionOptions = {}): number {\n    return convert(this.amount, this.unit, TimeUnit.Minutes, opts);\n  }\n\n  /**\n   * Return the total number of hours in this Duration\n   *\n   * @returns the value of this `Duration` expressed in Hours.\n   */\n  public toHours(opts: TimeConversionOptions = {}): number {\n    return convert(this.amount, this.unit, TimeUnit.Hours, opts);\n  }\n\n  /**\n   * Return the total number of days in this Duration\n   *\n   * @returns the value of this `Duration` expressed in Days.\n   */\n  public toDays(opts: TimeConversionOptions = {}): number {\n    return convert(this.amount, this.unit, TimeUnit.Days, opts);\n  }\n\n  /**\n   * Return an ISO 8601 representation of this period\n   *\n   * @returns a string starting with 'P' describing the period\n   * @see https://www.iso.org/standard/70907.html\n   */\n  public toIsoString(): string {\n    if (this.amount === 0) {\n      return \"PT0S\";\n    }\n\n    const ret = [\"P\"];\n    let tee = false;\n\n    for (const [amount, unit] of this.components(true)) {\n      if (\n        [TimeUnit.Seconds, TimeUnit.Minutes, TimeUnit.Hours].includes(unit) &&\n        !tee\n      ) {\n        ret.push(\"T\");\n        tee = true;\n      }\n      ret.push(`${amount}${unit.isoLabel}`);\n    }\n\n    return ret.join(\"\");\n  }\n\n  /**\n   * Return an ISO 8601 representation of this period\n   *\n   * @returns a string starting with 'P' describing the period\n   * @see https://www.iso.org/standard/70907.html\n   * @deprecated Use `toIsoString()` instead.\n   */\n  public toISOString(): string {\n    return this.toIsoString();\n  }\n\n  /**\n   * Turn this duration into a human-readable string\n   */\n  public toHumanString(): string {\n    if (this.amount === 0) {\n      return fmtUnit(0, this.unit);\n    }\n    if (Token.isUnresolved(this.amount)) {\n      return `<token> ${this.unit.label}`;\n    }\n\n    return (\n      this.components(false)\n        // 2 significant parts, that's totally enough for humans\n        .slice(0, 2)\n        .map(([amount, unit]) => fmtUnit(amount, unit))\n        .join(\" \")\n    );\n\n    function fmtUnit(amount: number, unit: TimeUnit) {\n      if (amount === 1) {\n        // All of the labels end in 's'\n        return `${amount} ${unit.label.substring(0, unit.label.length - 1)}`;\n      }\n      return `${amount} ${unit.label}`;\n    }\n  }\n\n  /**\n   * Returns a string representation of this `Duration`\n   *\n   * This is is never the right function to use when you want to use the `Duration`\n   * object in a template. Use `toSeconds()`, `toMinutes()`, `toDays()`, etc. instead.\n   */\n  public toString(): string {\n    return `Duration.${this.unit.label}(${this.amount})`;\n  }\n\n  /**\n   * Return the duration in a set of whole numbered time components, ordered from largest to smallest\n   *\n   * Only components != 0 will be returned.\n   *\n   * Can combine millis and seconds together for the benefit of toIsoString,\n   * makes the logic in there simpler.\n   */\n  private components(\n    combineMillisWithSeconds: boolean,\n  ): Array<[number, TimeUnit]> {\n    const ret = new Array<[number, TimeUnit]>();\n    let millis = convert(this.amount, this.unit, TimeUnit.Milliseconds, {\n      integral: false,\n    });\n\n    for (const unit of [\n      TimeUnit.Days,\n      TimeUnit.Hours,\n      TimeUnit.Minutes,\n      TimeUnit.Seconds,\n    ]) {\n      const count = convert(millis, TimeUnit.Milliseconds, unit, {\n        integral: false,\n      });\n      // Round down to a whole number UNLESS we're combining millis and seconds and we got to the seconds\n      const wholeCount =\n        unit === TimeUnit.Seconds && combineMillisWithSeconds\n          ? count\n          : Math.floor(count);\n      if (wholeCount > 0) {\n        ret.push([wholeCount, unit]);\n        millis -= wholeCount * unit.inMillis;\n      }\n    }\n\n    // Remainder in millis (keep only above threshold)\n    if (millis > 0.0001) {\n      ret.push([millis, TimeUnit.Milliseconds]);\n    }\n    return ret;\n  }\n\n  /**\n   * Checks if duration is a token or a resolvable object\n   */\n  public isUnresolved() {\n    return Token.isUnresolved(this.amount);\n  }\n\n  /**\n   * Returns unit of the duration\n   */\n  public unitLabel() {\n    return this.unit.label;\n  }\n\n  /**\n   * Returns stringified number of duration\n   */\n  public formatTokenToNumber(): string {\n    const number = Tokenization.stringifyNumber(this.amount);\n    return `${number} ${this.unit.label}`;\n  }\n}\n\n/**\n * Options for how to convert time to a different unit.\n */\nexport interface TimeConversionOptions {\n  /**\n   * If `true`, conversions into a larger time unit (e.g. `Seconds` to `Minutes`) will fail if the result is not an\n   * integer.\n   *\n   * @default true\n   */\n  readonly integral?: boolean;\n}\n\nclass TimeUnit {\n  public static readonly Milliseconds = new TimeUnit(\"millis\", \"\", 1);\n  public static readonly Seconds = new TimeUnit(\"seconds\", \"S\", 1_000);\n  public static readonly Minutes = new TimeUnit(\"minutes\", \"M\", 60_000);\n  public static readonly Hours = new TimeUnit(\"hours\", \"H\", 3_600_000);\n  public static readonly Days = new TimeUnit(\"days\", \"D\", 86_400_000);\n\n  private constructor(\n    public readonly label: string,\n    public readonly isoLabel: string,\n    public readonly inMillis: number,\n  ) {\n    // MAX_SAFE_INTEGER is 2^53, so by representing our duration in millis (the lowest\n    // common unit) the highest duration we can represent is\n    // 2^53 / 86*10^6 ~= 104 * 10^6 days (about 100 million days).\n  }\n\n  public toString() {\n    return this.label;\n  }\n}\n\nfunction convert(\n  amount: number,\n  fromUnit: TimeUnit,\n  toUnit: TimeUnit,\n  { integral = true }: TimeConversionOptions,\n) {\n  if (fromUnit.inMillis === toUnit.inMillis) {\n    if (integral && !Token.isUnresolved(amount) && !Number.isInteger(amount)) {\n      throw new Error(`${amount} must be a whole number of ${toUnit}.`);\n    }\n    return amount;\n  }\n  if (Token.isUnresolved(amount)) {\n    throw new Error(\n      `Duration must be specified as 'Duration.${toUnit}()' here since its value comes from a token and cannot be converted (got Duration.${fromUnit})`,\n    );\n  }\n  const value = (amount * fromUnit.inMillis) / toUnit.inMillis;\n  if (!Number.isInteger(value) && integral) {\n    throw new Error(\n      `'${amount} ${fromUnit}' cannot be converted into a whole number of ${toUnit}.`,\n    );\n  }\n  return value;\n}\n\n/**\n * Return the time unit with highest granularity\n */\nfunction finestUnit(a: TimeUnit, b: TimeUnit) {\n  return a.inMillis < b.inMillis ? a : b;\n}\n"]}

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./construct-base";
+export * from "./stack-base";
+export * from "./duration";
+export * from "./size";
+export * as aws from "./aws";

package/lib/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aws = void 0;
+__exportStar(require("./construct-base"), exports);
+__exportStar(require("./stack-base"), exports);
+__exportStar(require("./duration"), exports);
+__exportStar(require("./size"), exports);
+// cloud specific exports
+exports.aws = require("./aws");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxtREFBaUM7QUFDakMsK0NBQTZCO0FBQzdCLDZDQUEyQjtBQUMzQix5Q0FBdUI7QUFFdkIseUJBQXlCO0FBQ3pCLCtCQUE2QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbnN0cnVjdC1iYXNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zdGFjay1iYXNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kdXJhdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2l6ZVwiO1xuXG4vLyBjbG91ZCBzcGVjaWZpYyBleHBvcnRzXG5leHBvcnQgKiBhcyBhd3MgZnJvbSBcIi4vYXdzXCI7XG4iXX0=

package/lib/private/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./unique-resource-name";
+export * from "./terraform-dependables-aspect";

package/lib/private/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./unique-resource-name"), exports);
+__exportStar(require("./terraform-dependables-aspect"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJpdmF0ZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseURBQXVDO0FBQ3ZDLGlFQUErQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL3VuaXF1ZS1yZXNvdXJjZS1uYW1lXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90ZXJyYWZvcm0tZGVwZW5kYWJsZXMtYXNwZWN0XCI7XG4iXX0=

package/lib/private/terraform-dependables-aspect.d.ts

@@ -0,0 +1,20 @@
+import { IAspect } from "cdktf";
+import { IConstruct } from "constructs";
+export declare const SKIP_DEPENDENCY_PROPAGATION: unique symbol;
+/**
+ * Aspect that maps construct-level dependencies to the CDKTF dependsOn
+ * array of terraform datasources and resources.
+ *
+ * This Aspect propagates dependencies assigned from parent scopes all the way down
+ * to each child resource.
+ *
+ * ref:
+ * - https://github.com/hashicorp/terraform-cdk/issues/2727#issuecomment-1473321075
+ * - https://github.com/hashicorp/terraform-cdk/issues/785
+ * - https://github.com/winglang/wing/issues/3225
+ */
+export declare class TerraformDependencyAspect implements IAspect {
+    private resourceCache;
+    private dependencyCache;
+    visit(c: IConstruct): void;
+}

package/lib/private/terraform-dependables-aspect.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerraformDependencyAspect = exports.SKIP_DEPENDENCY_PROPAGATION = void 0;
+const cdktf_1 = require("cdktf");
+exports.SKIP_DEPENDENCY_PROPAGATION = Symbol.for("terraconstructs/lib/skip_dependency_propagation");
+/**
+ * Aspect that maps construct-level dependencies to the CDKTF dependsOn
+ * array of terraform datasources and resources.
+ *
+ * This Aspect propagates dependencies assigned from parent scopes all the way down
+ * to each child resource.
+ *
+ * ref:
+ * - https://github.com/hashicorp/terraform-cdk/issues/2727#issuecomment-1473321075
+ * - https://github.com/hashicorp/terraform-cdk/issues/785
+ * - https://github.com/winglang/wing/issues/3225
+ */
+class TerraformDependencyAspect {
+    constructor() {
+        // TODO: Ideally this is handled upstream in CDKTF
+        // Cache for resources defined within a construct's subtree
+        this.resourceCache = new Map();
+        // Cache for accumulated dependencies of a construct
+        this.dependencyCache = new Map();
+    }
+    // This method is called on every Construct within the specified scope (resources, data sources, etc.).
+    visit(c) {
+        // TODO: There seems to be a bug, this is temp fix...
+        if (exports.SKIP_DEPENDENCY_PROPAGATION in c) {
+            // use Object.prototype.hasOwnProperty.call(c, SKIP_DEPENDENCY_PROPAGATION) instead?
+            return;
+        }
+        // get dependencies from parent or init new set
+        let dependencies;
+        if (c.node.scope) {
+            const parentDependencies = this.dependencyCache.get(c.node.scope);
+            dependencies = new Set(parentDependencies);
+        }
+        if (!dependencies) {
+            dependencies = new Set();
+        }
+        // add all L1 resources of any construct dependencies
+        for (const dep of c.node.dependencies) {
+            const tfDependables = getTerraformDependables(dep, this.resourceCache);
+            for (const tfDependable of tfDependables) {
+                dependencies.add(tfDependable);
+            }
+        }
+        // map to dependsOn
+        if (dependencies.size > 0 && isL1Resource(c)) {
+            if (!c.dependsOn) {
+                c.dependsOn = [];
+            }
+            for (const dep of dependencies) {
+                if (dep !== c && !c.dependsOn.includes((0, cdktf_1.dependable)(dep))) {
+                    c.dependsOn.push((0, cdktf_1.dependable)(dep));
+                }
+            }
+        }
+        // cache dependencies for this construct
+        this.dependencyCache.set(c, dependencies);
+    }
+}
+exports.TerraformDependencyAspect = TerraformDependencyAspect;
+/**
+ * Type guard to check if an object is a CDKTF L1 Resource
+ * (TerraformResource or TerraformDataSource)
+ */
+function isL1Resource(x) {
+    return (cdktf_1.TerraformResource.isTerraformResource(x) ||
+        cdktf_1.TerraformDataSource.isTerraformDataSource(x));
+}
+/**
+ * Collects all L1 resources defined within a construct's subtree.
+ */
+function getTerraformDependables(c, cache) {
+    let resources = cache.get(c);
+    if (resources) {
+        return resources;
+    }
+    resources = new Set();
+    if (isL1Resource(c)) {
+        resources.add(c);
+    }
+    // Visit children
+    for (const child of c.node.children) {
+        const childResources = getTerraformDependables(child, cache);
+        for (const res of childResources) {
+            resources.add(res);
+        }
+    }
+    cache.set(c, resources);
+    return resources;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/private/unique-resource-name.d.ts

@@ -0,0 +1,9 @@
+import { UniqueResourceNameOptions, UniqueResourceNamePrefixOptions } from "../stack-base";
+/**
+ * Use path hash to generate a unique id from the set of components.
+ */
+export declare function makeUniqueResourceName(components: string[], options: UniqueResourceNameOptions): string;
+/**
+ * Does not use Path Hash and relies on provider generated suffix instead
+ */
+export declare function makeUniqueResourceNamePrefix(components: string[], options: UniqueResourceNamePrefixOptions): string;