terraconstructs 0.0.8

package/lib/private/unique-resource-name.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUniqueResourceNamePrefix = exports.makeUniqueResourceName = void 0;
+const crypto = require("crypto");
+// import { Token } from "cdktf";
+const errors_1 = require("cdktf/lib/errors");
+// https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/core/lib/private/unique-resource-name.ts
+/**
+ * Resources with this ID are hidden from humans
+ *
+ * They do not appear in the human-readable part of the logical ID,
+ * but they are included in the hash calculation.
+ */
+const HIDDEN_FROM_HUMAN_ID = "Resource";
+/**
+ * Resources with this ID are complete hidden from the logical ID calculation.
+ */
+const HIDDEN_ID = "Default";
+const PATH_SEP = "/";
+const MAX_LEN = 256;
+const HASH_LEN = 8;
+/**
+ * Use path hash to generate a unique id from the set of components.
+ */
+function makeUniqueResourceName(components, options) {
+    const maxLength = options.maxLength ?? 256;
+    const separator = options.separator ?? "";
+    const prefix = options.prefix ?? "";
+    const lowerCase = options.lowerCase ?? false;
+    components = components.filter((x) => x !== HIDDEN_ID);
+    if (components.length === 0) {
+        throw (0, errors_1.cannotCalcIdForEmptySetOfComponents)();
+    }
+    // top-level resources will simply use the `name` as-is if the name is also short enough.
+    if (components.length === 1) {
+        let topLevelResource = prefix +
+            removeNonAllowedSpecialCharacters(components[0], options.allowedSpecialCharacters);
+        if (lowerCase) {
+            topLevelResource = topLevelResource.toLowerCase();
+        }
+        if (topLevelResource.length <= maxLength) {
+            return topLevelResource;
+        }
+    }
+    // Calculate the hash from the full path, included unresolved tokens so the hash value is always unique
+    const hash = pathHash(components);
+    let human = prefix +
+        removeDupes(components)
+            .filter((pathElement) => pathElement !== HIDDEN_FROM_HUMAN_ID)
+            .map((pathElement) => removeNonAllowedSpecialCharacters(pathElement, options.allowedSpecialCharacters))
+            .filter((pathElement) => pathElement)
+            .join(separator)
+            .concat(separator);
+    if (lowerCase) {
+        human = human.toLowerCase();
+    }
+    const maxhumanLength = maxLength - HASH_LEN;
+    return human.length > maxhumanLength
+        ? `${splitInMiddle(human, maxhumanLength)}${hash}`
+        : `${human}${hash}`;
+}
+exports.makeUniqueResourceName = makeUniqueResourceName;
+/**
+ * Does not use Path Hash and relies on provider generated suffix instead
+ */
+function makeUniqueResourceNamePrefix(components, options) {
+    const suffixLength = options.suffixLength ?? 26; // terraform provider aws generates a 26 character suffix
+    const maxLength = (options.maxLength ?? 256) - suffixLength;
+    const separator = options.separator ?? "";
+    const prefix = options.prefix ?? "";
+    const lowerCase = options.lowerCase ?? false;
+    components = components.filter((x) => x !== HIDDEN_ID);
+    if (components.length === 0) {
+        throw (0, errors_1.cannotCalcIdForEmptySetOfComponents)();
+    }
+    // top-level resources will simply use the `name` as-is if the name is also short enough.
+    if (components.length === 1) {
+        let topLevelResource = prefix +
+            removeNonAllowedSpecialCharacters(components[0], options.allowedSpecialCharacters);
+        if (lowerCase) {
+            topLevelResource = topLevelResource.toLowerCase();
+        }
+        if (topLevelResource.length <= maxLength) {
+            return topLevelResource;
+        }
+    }
+    let human = prefix +
+        removeDupes(components)
+            .filter((pathElement) => pathElement !== HIDDEN_FROM_HUMAN_ID)
+            .map((pathElement) => removeNonAllowedSpecialCharacters(pathElement, options.allowedSpecialCharacters))
+            .filter((pathElement) => pathElement)
+            .join(separator)
+            .concat(separator);
+    if (lowerCase) {
+        human = human.toLowerCase();
+    }
+    // TODO: does it make sense to split in the middle for these?
+    // Or try to presserve the passed in prefix at all times?
+    return human.length > maxLength
+        ? `${splitInMiddle(human, maxLength)}`
+        : `${human}`;
+}
+exports.makeUniqueResourceNamePrefix = makeUniqueResourceNamePrefix;
+/**
+ * Take a hash of the given path.
+ *
+ * The hash is limited in size.
+ */
+function pathHash(path) {
+    const md5 = crypto
+        .createHash("md5")
+        .update(path.join(PATH_SEP))
+        .digest("hex");
+    return md5.slice(0, HASH_LEN).toUpperCase();
+}
+/**
+ * Removes all non-allowed special characters in a string.
+ */
+function removeNonAllowedSpecialCharacters(s, allowedSpecialCharacters) {
+    const pattern = allowedSpecialCharacters
+        ? `[^A-Za-z0-9${allowedSpecialCharacters}]`
+        : "[^A-Za-z0-9]";
+    const regex = new RegExp(pattern, "g");
+    return s.replace(regex, "");
+}
+/**
+ * Remove duplicate "terms" from the path list
+ *
+ * If the previous path component name ends with this component name, skip the
+ * current component.
+ */
+function removeDupes(path) {
+    const ret = new Array();
+    for (const component of path) {
+        if (ret.length === 0 || !ret[ret.length - 1].endsWith(component)) {
+            ret.push(component);
+        }
+    }
+    return ret;
+}
+function splitInMiddle(s, maxLength = MAX_LEN - HASH_LEN) {
+    const half = maxLength / 2;
+    return s.slice(0, half) + s.slice(-half);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unique-resource-name.js","sourceRoot":"","sources":["../../src/private/unique-resource-name.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from \"crypto\";\n// import { Token } from \"cdktf\";\nimport { cannotCalcIdForEmptySetOfComponents } from \"cdktf/lib/errors\";\nimport {\n  UniqueResourceNameOptions,\n  UniqueResourceNamePrefixOptions,\n} from \"../stack-base\";\n\n// https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/core/lib/private/unique-resource-name.ts\n\n/**\n * Resources with this ID are hidden from humans\n *\n * They do not appear in the human-readable part of the logical ID,\n * but they are included in the hash calculation.\n */\nconst HIDDEN_FROM_HUMAN_ID = \"Resource\";\n\n/**\n * Resources with this ID are complete hidden from the logical ID calculation.\n */\nconst HIDDEN_ID = \"Default\";\n\nconst PATH_SEP = \"/\";\n\nconst MAX_LEN = 256;\n\nconst HASH_LEN = 8;\n\n/**\n * Use path hash to generate a unique id from the set of components.\n */\nexport function makeUniqueResourceName(\n  components: string[],\n  options: UniqueResourceNameOptions,\n) {\n  const maxLength = options.maxLength ?? 256;\n  const separator = options.separator ?? \"\";\n  const prefix = options.prefix ?? \"\";\n  const lowerCase = options.lowerCase ?? false;\n  components = components.filter((x) => x !== HIDDEN_ID);\n\n  if (components.length === 0) {\n    throw cannotCalcIdForEmptySetOfComponents();\n  }\n\n  // top-level resources will simply use the `name` as-is if the name is also short enough.\n  if (components.length === 1) {\n    let topLevelResource =\n      prefix +\n      removeNonAllowedSpecialCharacters(\n        components[0],\n        options.allowedSpecialCharacters,\n      );\n\n    if (lowerCase) {\n      topLevelResource = topLevelResource.toLowerCase();\n    }\n\n    if (topLevelResource.length <= maxLength) {\n      return topLevelResource;\n    }\n  }\n\n  // Calculate the hash from the full path, included unresolved tokens so the hash value is always unique\n  const hash = pathHash(components);\n  let human =\n    prefix +\n    removeDupes(components)\n      .filter((pathElement) => pathElement !== HIDDEN_FROM_HUMAN_ID)\n      .map((pathElement) =>\n        removeNonAllowedSpecialCharacters(\n          pathElement,\n          options.allowedSpecialCharacters,\n        ),\n      )\n      .filter((pathElement) => pathElement)\n      .join(separator)\n      .concat(separator);\n\n  if (lowerCase) {\n    human = human.toLowerCase();\n  }\n\n  const maxhumanLength = maxLength - HASH_LEN;\n  return human.length > maxhumanLength\n    ? `${splitInMiddle(human, maxhumanLength)}${hash}`\n    : `${human}${hash}`;\n}\n\n/**\n * Does not use Path Hash and relies on provider generated suffix instead\n */\nexport function makeUniqueResourceNamePrefix(\n  components: string[],\n  options: UniqueResourceNamePrefixOptions,\n) {\n  const suffixLength = options.suffixLength ?? 26; // terraform provider aws generates a 26 character suffix\n  const maxLength = (options.maxLength ?? 256) - suffixLength;\n  const separator = options.separator ?? \"\";\n  const prefix = options.prefix ?? \"\";\n  const lowerCase = options.lowerCase ?? false;\n  components = components.filter((x) => x !== HIDDEN_ID);\n\n  if (components.length === 0) {\n    throw cannotCalcIdForEmptySetOfComponents();\n  }\n\n  // top-level resources will simply use the `name` as-is if the name is also short enough.\n  if (components.length === 1) {\n    let topLevelResource =\n      prefix +\n      removeNonAllowedSpecialCharacters(\n        components[0],\n        options.allowedSpecialCharacters,\n      );\n\n    if (lowerCase) {\n      topLevelResource = topLevelResource.toLowerCase();\n    }\n\n    if (topLevelResource.length <= maxLength) {\n      return topLevelResource;\n    }\n  }\n\n  let human =\n    prefix +\n    removeDupes(components)\n      .filter((pathElement) => pathElement !== HIDDEN_FROM_HUMAN_ID)\n      .map((pathElement) =>\n        removeNonAllowedSpecialCharacters(\n          pathElement,\n          options.allowedSpecialCharacters,\n        ),\n      )\n      .filter((pathElement) => pathElement)\n      .join(separator)\n      .concat(separator);\n\n  if (lowerCase) {\n    human = human.toLowerCase();\n  }\n\n  // TODO: does it make sense to split in the middle for these?\n  // Or try to presserve the passed in prefix at all times?\n  return human.length > maxLength\n    ? `${splitInMiddle(human, maxLength)}`\n    : `${human}`;\n}\n\n/**\n * Take a hash of the given path.\n *\n * The hash is limited in size.\n */\nfunction pathHash(path: string[]): string {\n  const md5 = crypto\n    .createHash(\"md5\")\n    .update(path.join(PATH_SEP))\n    .digest(\"hex\");\n  return md5.slice(0, HASH_LEN).toUpperCase();\n}\n\n/**\n * Removes all non-allowed special characters in a string.\n */\nfunction removeNonAllowedSpecialCharacters(\n  s: string,\n  allowedSpecialCharacters?: string,\n) {\n  const pattern = allowedSpecialCharacters\n    ? `[^A-Za-z0-9${allowedSpecialCharacters}]`\n    : \"[^A-Za-z0-9]\";\n  const regex = new RegExp(pattern, \"g\");\n  return s.replace(regex, \"\");\n}\n\n/**\n * Remove duplicate \"terms\" from the path list\n *\n * If the previous path component name ends with this component name, skip the\n * current component.\n */\nfunction removeDupes(path: string[]): string[] {\n  const ret = new Array<string>();\n\n  for (const component of path) {\n    if (ret.length === 0 || !ret[ret.length - 1].endsWith(component)) {\n      ret.push(component);\n    }\n  }\n  return ret;\n}\n\nfunction splitInMiddle(s: string, maxLength: number = MAX_LEN - HASH_LEN) {\n  const half = maxLength / 2;\n  return s.slice(0, half) + s.slice(-half);\n}\n"]}

package/lib/size.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Represents the amount of digital storage.
+ *
+ * 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.
+ */
+export declare class Size {
+    /**
+     * Create a Storage representing an amount bytes.
+     *
+     * @param amount the amount of bytes to be represented
+     *
+     * @returns a new `Size` instance
+     */
+    static bytes(amount: number): Size;
+    /**
+     * Create a Storage representing an amount kibibytes.
+     * 1 KiB = 1024 bytes
+     *
+     * @param amount the amount of kibibytes to be represented
+     *
+     * @returns a new `Size` instance
+     */
+    static kibibytes(amount: number): Size;
+    /**
+     * Create a Storage representing an amount mebibytes.
+     * 1 MiB = 1024 KiB
+     *
+     * @param amount the amount of mebibytes to be represented
+     *
+     * @returns a new `Size` instance
+     */
+    static mebibytes(amount: number): Size;
+    /**
+     * Create a Storage representing an amount gibibytes.
+     * 1 GiB = 1024 MiB
+     *
+     * @param amount the amount of gibibytes to be represented
+     *
+     * @returns a new `Size` instance
+     */
+    static gibibytes(amount: number): Size;
+    /**
+     * Create a Storage representing an amount tebibytes.
+     * 1 TiB = 1024 GiB
+     *
+     * @param amount the amount of tebibytes to be represented
+     *
+     * @returns a new `Size` instance
+     */
+    static tebibytes(amount: number): Size;
+    /**
+     * Create a Storage representing an amount pebibytes.
+     * 1 PiB = 1024 TiB
+     *
+     * @deprecated use `pebibytes` instead
+     */
+    static pebibyte(amount: number): Size;
+    /**
+     * Create a Storage representing an amount pebibytes.
+     * 1 PiB = 1024 TiB
+     *
+     * @param amount the amount of pebibytes to be represented
+     *
+     * @returns a new `Size` instance
+     */
+    static pebibytes(amount: number): Size;
+    private readonly amount;
+    private readonly unit;
+    private constructor();
+    /**
+     * Return this storage as a total number of bytes.
+     *
+     * @param opts the conversion options
+     *
+     * @returns the quantity expressed in bytes
+     */
+    toBytes(opts?: SizeConversionOptions): number;
+    /**
+     * Return this storage as a total number of kibibytes.
+     *
+     * @param opts the conversion options
+     *
+     * @returns the quantity of bytes expressed in kibibytes
+     */
+    toKibibytes(opts?: SizeConversionOptions): number;
+    /**
+     * Return this storage as a total number of mebibytes.
+     *
+     * @param opts the conversion options
+     *
+     * @returns the quantity of bytes expressed in mebibytes
+     */
+    toMebibytes(opts?: SizeConversionOptions): number;
+    /**
+     * Return this storage as a total number of gibibytes.
+     *
+     * @param opts the conversion options
+     *
+     * @returns the quantity of bytes expressed in gibibytes
+     */
+    toGibibytes(opts?: SizeConversionOptions): number;
+    /**
+     * Return this storage as a total number of tebibytes.
+     *
+     * @param opts the conversion options
+     *
+     * @returns the quantity of bytes expressed in tebibytes
+     */
+    toTebibytes(opts?: SizeConversionOptions): number;
+    /**
+     * Return this storage as a total number of pebibytes.
+     *
+     * @param opts the conversion options
+     *
+     * @returns the quantity of bytes expressed in pebibytes
+     */
+    toPebibytes(opts?: SizeConversionOptions): number;
+    /**
+     * Checks if size is a token or a resolvable object
+     */
+    isUnresolved(): boolean;
+}
+/**
+ * Rounding behaviour when converting between units of `Size`.
+ */
+export declare enum SizeRoundingBehavior {
+    /** Fail the conversion if the result is not an integer. */
+    FAIL = 0,
+    /** If the result is not an integer, round it to the closest integer less than the result */
+    FLOOR = 1,
+    /** Don't round. Return even if the result is a fraction. */
+    NONE = 2
+}
+/**
+ * Options for how to convert time to a different unit.
+ */
+export interface SizeConversionOptions {
+    /**
+     * How conversions should behave when it encounters a non-integer result
+     * @default SizeRoundingBehavior.FAIL
+     */
+    readonly rounding?: SizeRoundingBehavior;
+}

package/lib/size.js

@@ -0,0 +1,220 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SizeRoundingBehavior = exports.Size = 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/size.ts
+const cdktf_1 = require("cdktf");
+/**
+ * Represents the amount of digital storage.
+ *
+ * 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 Size {
+    /**
+     * Create a Storage representing an amount bytes.
+     *
+     * @param amount the amount of bytes to be represented
+     *
+     * @returns a new `Size` instance
+     */
+    static bytes(amount) {
+        return new Size(amount, StorageUnit.Bytes);
+    }
+    /**
+     * Create a Storage representing an amount kibibytes.
+     * 1 KiB = 1024 bytes
+     *
+     * @param amount the amount of kibibytes to be represented
+     *
+     * @returns a new `Size` instance
+     */
+    static kibibytes(amount) {
+        return new Size(amount, StorageUnit.Kibibytes);
+    }
+    /**
+     * Create a Storage representing an amount mebibytes.
+     * 1 MiB = 1024 KiB
+     *
+     * @param amount the amount of mebibytes to be represented
+     *
+     * @returns a new `Size` instance
+     */
+    static mebibytes(amount) {
+        return new Size(amount, StorageUnit.Mebibytes);
+    }
+    /**
+     * Create a Storage representing an amount gibibytes.
+     * 1 GiB = 1024 MiB
+     *
+     * @param amount the amount of gibibytes to be represented
+     *
+     * @returns a new `Size` instance
+     */
+    static gibibytes(amount) {
+        return new Size(amount, StorageUnit.Gibibytes);
+    }
+    /**
+     * Create a Storage representing an amount tebibytes.
+     * 1 TiB = 1024 GiB
+     *
+     * @param amount the amount of tebibytes to be represented
+     *
+     * @returns a new `Size` instance
+     */
+    static tebibytes(amount) {
+        return new Size(amount, StorageUnit.Tebibytes);
+    }
+    /**
+     * Create a Storage representing an amount pebibytes.
+     * 1 PiB = 1024 TiB
+     *
+     * @deprecated use `pebibytes` instead
+     */
+    static pebibyte(amount) {
+        return Size.pebibytes(amount);
+    }
+    /**
+     * Create a Storage representing an amount pebibytes.
+     * 1 PiB = 1024 TiB
+     *
+     * @param amount the amount of pebibytes to be represented
+     *
+     * @returns a new `Size` instance
+     */
+    static pebibytes(amount) {
+        return new Size(amount, StorageUnit.Pebibytes);
+    }
+    constructor(amount, unit) {
+        if (!cdktf_1.Token.isUnresolved(amount) && amount < 0) {
+            throw new Error(`Storage amounts cannot be negative. Received: ${amount}`);
+        }
+        this.amount = amount;
+        this.unit = unit;
+    }
+    /**
+     * Return this storage as a total number of bytes.
+     *
+     * @param opts the conversion options
+     *
+     * @returns the quantity expressed in bytes
+     */
+    toBytes(opts = {}) {
+        return convert(this.amount, this.unit, StorageUnit.Bytes, opts);
+    }
+    /**
+     * Return this storage as a total number of kibibytes.
+     *
+     * @param opts the conversion options
+     *
+     * @returns the quantity of bytes expressed in kibibytes
+     */
+    toKibibytes(opts = {}) {
+        return convert(this.amount, this.unit, StorageUnit.Kibibytes, opts);
+    }
+    /**
+     * Return this storage as a total number of mebibytes.
+     *
+     * @param opts the conversion options
+     *
+     * @returns the quantity of bytes expressed in mebibytes
+     */
+    toMebibytes(opts = {}) {
+        return convert(this.amount, this.unit, StorageUnit.Mebibytes, opts);
+    }
+    /**
+     * Return this storage as a total number of gibibytes.
+     *
+     * @param opts the conversion options
+     *
+     * @returns the quantity of bytes expressed in gibibytes
+     */
+    toGibibytes(opts = {}) {
+        return convert(this.amount, this.unit, StorageUnit.Gibibytes, opts);
+    }
+    /**
+     * Return this storage as a total number of tebibytes.
+     *
+     * @param opts the conversion options
+     *
+     * @returns the quantity of bytes expressed in tebibytes
+     */
+    toTebibytes(opts = {}) {
+        return convert(this.amount, this.unit, StorageUnit.Tebibytes, opts);
+    }
+    /**
+     * Return this storage as a total number of pebibytes.
+     *
+     * @param opts the conversion options
+     *
+     * @returns the quantity of bytes expressed in pebibytes
+     */
+    toPebibytes(opts = {}) {
+        return convert(this.amount, this.unit, StorageUnit.Pebibytes, opts);
+    }
+    /**
+     * Checks if size is a token or a resolvable object
+     */
+    isUnresolved() {
+        return cdktf_1.Token.isUnresolved(this.amount);
+    }
+}
+exports.Size = Size;
+_a = JSII_RTTI_SYMBOL_1;
+Size[_a] = { fqn: "terraconstructs.Size", version: "0.0.8" };
+/**
+ * Rounding behaviour when converting between units of `Size`.
+ */
+var SizeRoundingBehavior;
+(function (SizeRoundingBehavior) {
+    /** Fail the conversion if the result is not an integer. */
+    SizeRoundingBehavior[SizeRoundingBehavior["FAIL"] = 0] = "FAIL";
+    /** If the result is not an integer, round it to the closest integer less than the result */
+    SizeRoundingBehavior[SizeRoundingBehavior["FLOOR"] = 1] = "FLOOR";
+    /** Don't round. Return even if the result is a fraction. */
+    SizeRoundingBehavior[SizeRoundingBehavior["NONE"] = 2] = "NONE";
+})(SizeRoundingBehavior || (exports.SizeRoundingBehavior = SizeRoundingBehavior = {}));
+class StorageUnit {
+    constructor(label, inBytes) {
+        this.label = label;
+        this.inBytes = inBytes;
+        // MAX_SAFE_INTEGER is 2^53, so by representing storage in kibibytes,
+        // the highest storage we can represent is 8 exbibytes.
+    }
+    toString() {
+        return this.label;
+    }
+}
+StorageUnit.Bytes = new StorageUnit("bytes", 1);
+StorageUnit.Kibibytes = new StorageUnit("kibibytes", 1024);
+StorageUnit.Mebibytes = new StorageUnit("mebibytes", 1024 * 1024);
+StorageUnit.Gibibytes = new StorageUnit("gibibytes", 1024 * 1024 * 1024);
+StorageUnit.Tebibytes = new StorageUnit("tebibytes", 1024 * 1024 * 1024 * 1024);
+StorageUnit.Pebibytes = new StorageUnit("pebibytes", 1024 * 1024 * 1024 * 1024 * 1024);
+function convert(amount, fromUnit, toUnit, options = {}) {
+    const rounding = options.rounding ?? SizeRoundingBehavior.FAIL;
+    if (fromUnit.inBytes === toUnit.inBytes) {
+        return amount;
+    }
+    if (cdktf_1.Token.isUnresolved(amount)) {
+        throw new Error(`Size must be specified as 'Size.${toUnit}()' here since its value comes from a token and cannot be converted (got Size.${fromUnit})`);
+    }
+    const multiplier = fromUnit.inBytes / toUnit.inBytes;
+    const value = amount * multiplier;
+    switch (rounding) {
+        case SizeRoundingBehavior.NONE:
+            return value;
+        case SizeRoundingBehavior.FLOOR:
+            return Math.floor(value);
+        default:
+        case SizeRoundingBehavior.FAIL:
+            if (!Number.isInteger(value)) {
+                throw new Error(`'${amount} ${fromUnit}' cannot be converted into a whole number of ${toUnit}.`);
+            }
+            return value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"size.js","sourceRoot":"","sources":["../src/size.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.154.1/packages/aws-cdk-lib/core/lib/size.ts\nimport { Token } from \"cdktf\";\n\n/**\n * Represents the amount of digital storage.\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 Size {\n  /**\n   * Create a Storage representing an amount bytes.\n   *\n   * @param amount the amount of bytes to be represented\n   *\n   * @returns a new `Size` instance\n   */\n  public static bytes(amount: number): Size {\n    return new Size(amount, StorageUnit.Bytes);\n  }\n\n  /**\n   * Create a Storage representing an amount kibibytes.\n   * 1 KiB = 1024 bytes\n   *\n   * @param amount the amount of kibibytes to be represented\n   *\n   * @returns a new `Size` instance\n   */\n  public static kibibytes(amount: number): Size {\n    return new Size(amount, StorageUnit.Kibibytes);\n  }\n\n  /**\n   * Create a Storage representing an amount mebibytes.\n   * 1 MiB = 1024 KiB\n   *\n   * @param amount the amount of mebibytes to be represented\n   *\n   * @returns a new `Size` instance\n   */\n  public static mebibytes(amount: number): Size {\n    return new Size(amount, StorageUnit.Mebibytes);\n  }\n\n  /**\n   * Create a Storage representing an amount gibibytes.\n   * 1 GiB = 1024 MiB\n   *\n   * @param amount the amount of gibibytes to be represented\n   *\n   * @returns a new `Size` instance\n   */\n  public static gibibytes(amount: number): Size {\n    return new Size(amount, StorageUnit.Gibibytes);\n  }\n\n  /**\n   * Create a Storage representing an amount tebibytes.\n   * 1 TiB = 1024 GiB\n   *\n   * @param amount the amount of tebibytes to be represented\n   *\n   * @returns a new `Size` instance\n   */\n  public static tebibytes(amount: number): Size {\n    return new Size(amount, StorageUnit.Tebibytes);\n  }\n\n  /**\n   * Create a Storage representing an amount pebibytes.\n   * 1 PiB = 1024 TiB\n   *\n   * @deprecated use `pebibytes` instead\n   */\n  public static pebibyte(amount: number): Size {\n    return Size.pebibytes(amount);\n  }\n\n  /**\n   * Create a Storage representing an amount pebibytes.\n   * 1 PiB = 1024 TiB\n   *\n   * @param amount the amount of pebibytes to be represented\n   *\n   * @returns a new `Size` instance\n   */\n  public static pebibytes(amount: number): Size {\n    return new Size(amount, StorageUnit.Pebibytes);\n  }\n\n  private readonly amount: number;\n  private readonly unit: StorageUnit;\n\n  private constructor(amount: number, unit: StorageUnit) {\n    if (!Token.isUnresolved(amount) && amount < 0) {\n      throw new Error(\n        `Storage amounts cannot be negative. Received: ${amount}`,\n      );\n    }\n    this.amount = amount;\n    this.unit = unit;\n  }\n\n  /**\n   * Return this storage as a total number of bytes.\n   *\n   * @param opts the conversion options\n   *\n   * @returns the quantity expressed in bytes\n   */\n  public toBytes(opts: SizeConversionOptions = {}): number {\n    return convert(this.amount, this.unit, StorageUnit.Bytes, opts);\n  }\n\n  /**\n   * Return this storage as a total number of kibibytes.\n   *\n   * @param opts the conversion options\n   *\n   * @returns the quantity of bytes expressed in kibibytes\n   */\n  public toKibibytes(opts: SizeConversionOptions = {}): number {\n    return convert(this.amount, this.unit, StorageUnit.Kibibytes, opts);\n  }\n\n  /**\n   * Return this storage as a total number of mebibytes.\n   *\n   * @param opts the conversion options\n   *\n   * @returns the quantity of bytes expressed in mebibytes\n   */\n  public toMebibytes(opts: SizeConversionOptions = {}): number {\n    return convert(this.amount, this.unit, StorageUnit.Mebibytes, opts);\n  }\n\n  /**\n   * Return this storage as a total number of gibibytes.\n   *\n   * @param opts the conversion options\n   *\n   * @returns the quantity of bytes expressed in gibibytes\n   */\n  public toGibibytes(opts: SizeConversionOptions = {}): number {\n    return convert(this.amount, this.unit, StorageUnit.Gibibytes, opts);\n  }\n\n  /**\n   * Return this storage as a total number of tebibytes.\n   *\n   * @param opts the conversion options\n   *\n   * @returns the quantity of bytes expressed in tebibytes\n   */\n  public toTebibytes(opts: SizeConversionOptions = {}): number {\n    return convert(this.amount, this.unit, StorageUnit.Tebibytes, opts);\n  }\n\n  /**\n   * Return this storage as a total number of pebibytes.\n   *\n   * @param opts the conversion options\n   *\n   * @returns the quantity of bytes expressed in pebibytes\n   */\n  public toPebibytes(opts: SizeConversionOptions = {}): number {\n    return convert(this.amount, this.unit, StorageUnit.Pebibytes, opts);\n  }\n\n  /**\n   * Checks if size is a token or a resolvable object\n   */\n  public isUnresolved() {\n    return Token.isUnresolved(this.amount);\n  }\n}\n\n/**\n * Rounding behaviour when converting between units of `Size`.\n */\nexport enum SizeRoundingBehavior {\n  /** Fail the conversion if the result is not an integer. */\n  FAIL,\n  /** If the result is not an integer, round it to the closest integer less than the result */\n  FLOOR,\n  /** Don't round. Return even if the result is a fraction. */\n  NONE,\n}\n\n/**\n * Options for how to convert time to a different unit.\n */\nexport interface SizeConversionOptions {\n  /**\n   * How conversions should behave when it encounters a non-integer result\n   * @default SizeRoundingBehavior.FAIL\n   */\n  readonly rounding?: SizeRoundingBehavior;\n}\n\nclass StorageUnit {\n  public static readonly Bytes = new StorageUnit(\"bytes\", 1);\n  public static readonly Kibibytes = new StorageUnit(\"kibibytes\", 1024);\n  public static readonly Mebibytes = new StorageUnit(\"mebibytes\", 1024 * 1024);\n  public static readonly Gibibytes = new StorageUnit(\n    \"gibibytes\",\n    1024 * 1024 * 1024,\n  );\n  public static readonly Tebibytes = new StorageUnit(\n    \"tebibytes\",\n    1024 * 1024 * 1024 * 1024,\n  );\n  public static readonly Pebibytes = new StorageUnit(\n    \"pebibytes\",\n    1024 * 1024 * 1024 * 1024 * 1024,\n  );\n\n  private constructor(\n    public readonly label: string,\n    public readonly inBytes: number,\n  ) {\n    // MAX_SAFE_INTEGER is 2^53, so by representing storage in kibibytes,\n    // the highest storage we can represent is 8 exbibytes.\n  }\n\n  public toString() {\n    return this.label;\n  }\n}\n\nfunction convert(\n  amount: number,\n  fromUnit: StorageUnit,\n  toUnit: StorageUnit,\n  options: SizeConversionOptions = {},\n) {\n  const rounding = options.rounding ?? SizeRoundingBehavior.FAIL;\n  if (fromUnit.inBytes === toUnit.inBytes) {\n    return amount;\n  }\n  if (Token.isUnresolved(amount)) {\n    throw new Error(\n      `Size must be specified as 'Size.${toUnit}()' here since its value comes from a token and cannot be converted (got Size.${fromUnit})`,\n    );\n  }\n\n  const multiplier = fromUnit.inBytes / toUnit.inBytes;\n  const value = amount * multiplier;\n  switch (rounding) {\n    case SizeRoundingBehavior.NONE:\n      return value;\n    case SizeRoundingBehavior.FLOOR:\n      return Math.floor(value);\n    default:\n    case SizeRoundingBehavior.FAIL:\n      if (!Number.isInteger(value)) {\n        throw new Error(\n          `'${amount} ${fromUnit}' cannot be converted into a whole number of ${toUnit}.`,\n        );\n      }\n      return value;\n  }\n}\n"]}