@react-stately/table 3.11.7-nightly.4552 → 3.11.7-nightly.4558

package/dist/TableHeader.module.js

@@ -0,0 +1,47 @@
+import $20k3Y$react from "react";
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+function $312ae3b56a94a86e$var$TableHeader(props) {
+    return null;
+}
+$312ae3b56a94a86e$var$TableHeader.getCollectionNode = function* getCollectionNode(props, context) {
+    let { children: children, columns: columns } = props;
+    // Clear columns so they aren't double added in strict mode.
+    context.columns = [];
+    if (typeof children === "function") {
+        if (!columns) throw new Error("props.children was a function but props.columns is missing");
+        for (let column of columns)yield {
+            type: "column",
+            value: column,
+            renderer: children
+        };
+    } else {
+        let columns = [];
+        (0, $20k3Y$react).Children.forEach(children, (column)=>{
+            columns.push({
+                type: "column",
+                element: column
+            });
+        });
+        yield* columns;
+    }
+};
+/**
+ * A TableHeader is a container for the Column elements in a Table. Columns can be statically defined
+ * as children, or generated dynamically using a function based on the data passed to the `columns` prop.
+ */ // We don't want getCollectionNode to show up in the type definition
+let $312ae3b56a94a86e$export$f850895b287ef28e = $312ae3b56a94a86e$var$TableHeader;
+
+
+export {$312ae3b56a94a86e$export$f850895b287ef28e as TableHeader};
+//# sourceMappingURL=TableHeader.module.js.map

package/dist/TableHeader.module.js.map

@@ -0,0 +1 @@
+{"mappings":";;AAAA;;;;;;;;;;CAUC;AAOD,SAAS,kCAAe,KAA0B;IAChD,OAAO;AACT;AAEA,kCAAY,iBAAiB,GAAG,UAAU,kBAAqB,KAA0B,EAAE,OAAoC;IAC7H,IAAI,YAAC,QAAQ,WAAE,OAAO,EAAC,GAAG;IAE1B,4DAA4D;IAC5D,QAAQ,OAAO,GAAG,EAAE;IAEpB,IAAI,OAAO,aAAa,YAAY;QAClC,IAAI,CAAC,SACH,MAAM,IAAI,MAAM;QAGlB,KAAK,IAAI,UAAU,QACjB,MAAM;YACJ,MAAM;YACN,OAAO;YACP,UAAU;QACZ;IAEJ,OAAO;QACL,IAAI,UAA4B,EAAE;QAClC,CAAA,GAAA,YAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,UAAU,CAAA;YAC/B,QAAQ,IAAI,CAAC;gBACX,MAAM;gBACN,SAAS;YACX;QACF;QAEA,OAAO;IACT;AACF;AAEA;;;CAGC,GACD,oEAAoE;AACpE,IAAI,4CAAe","sources":["packages/@react-stately/table/src/TableHeader.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {CollectionBuilderContext} from './useTableState';\nimport {PartialNode} from '@react-stately/collections';\nimport React, {JSX, ReactElement} from 'react';\nimport {TableHeaderProps} from '@react-types/table';\n\nfunction TableHeader<T>(props: TableHeaderProps<T>): ReactElement { // eslint-disable-line @typescript-eslint/no-unused-vars\n  return null;\n}\n\nTableHeader.getCollectionNode = function* getCollectionNode<T>(props: TableHeaderProps<T>, context: CollectionBuilderContext<T>): Generator<PartialNode<T>, void, any> {\n  let {children, columns} = props;\n\n  // Clear columns so they aren't double added in strict mode.\n  context.columns = [];\n\n  if (typeof children === 'function') {\n    if (!columns) {\n      throw new Error('props.children was a function but props.columns is missing');\n    }\n\n    for (let column of columns) {\n      yield {\n        type: 'column',\n        value: column,\n        renderer: children\n      };\n    }\n  } else {\n    let columns: PartialNode<T>[] = [];\n    React.Children.forEach(children, column => {\n      columns.push({\n        type: 'column',\n        element: column\n      });\n    });\n\n    yield* columns;\n  }\n};\n\n/**\n * A TableHeader is a container for the Column elements in a Table. Columns can be statically defined\n * as children, or generated dynamically using a function based on the data passed to the `columns` prop.\n */\n// We don't want getCollectionNode to show up in the type definition\nlet _TableHeader = TableHeader as <T>(props: TableHeaderProps<T>) => JSX.Element;\nexport {_TableHeader as TableHeader};\n"],"names":[],"version":3,"file":"TableHeader.module.js.map"}

package/dist/TableUtils.main.js

@@ -0,0 +1,184 @@
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+
+$parcel$export(module.exports, "isStatic", () => $9e5f6a0caf75716e$export$1994a077b98ee0d5);
+$parcel$export(module.exports, "parseFractionalUnit", () => $9e5f6a0caf75716e$export$9078bad4c3934604);
+$parcel$export(module.exports, "getMaxWidth", () => $9e5f6a0caf75716e$export$59185c62a7544aa0);
+$parcel$export(module.exports, "getMinWidth", () => $9e5f6a0caf75716e$export$f556054ce4358701);
+$parcel$export(module.exports, "calculateColumnSizes", () => $9e5f6a0caf75716e$export$55d50dc687385491);
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ function $9e5f6a0caf75716e$export$1994a077b98ee0d5(width) {
+    return width != null && (!isNaN(width) || String(width).match(/^(\d+)(?=%$)/) !== null);
+}
+function $9e5f6a0caf75716e$export$9078bad4c3934604(width) {
+    if (!width) return 1;
+    let match = width.match(/^(.+)(?=fr$)/);
+    // if width is the incorrect format, just default it to a 1fr
+    if (!match) {
+        console.warn(`width: ${width} is not a supported format, width should be a number (ex. 150), percentage (ex. '50%') or fr unit (ex. '2fr')`, "defaulting to '1fr'");
+        return 1;
+    }
+    return parseFloat(match[0]);
+}
+function $9e5f6a0caf75716e$export$7bbad27896f7ae9f(width, tableWidth) {
+    if (typeof width === "string") {
+        let match = width.match(/^(\d+)(?=%$)/);
+        if (!match) throw new Error("Only percentages or numbers are supported for static column widths");
+        return tableWidth * (parseFloat(match[0]) / 100);
+    }
+    return width;
+}
+function $9e5f6a0caf75716e$export$59185c62a7544aa0(maxWidth, tableWidth) {
+    return maxWidth != null ? $9e5f6a0caf75716e$export$7bbad27896f7ae9f(maxWidth, tableWidth) : Number.MAX_SAFE_INTEGER;
+}
+function $9e5f6a0caf75716e$export$f556054ce4358701(minWidth, tableWidth) {
+    return minWidth != null ? $9e5f6a0caf75716e$export$7bbad27896f7ae9f(minWidth, tableWidth) : 0;
+}
+function $9e5f6a0caf75716e$export$55d50dc687385491(availableWidth, columns, changedColumns, getDefaultWidth, getDefaultMinWidth) {
+    let hasNonFrozenItems = false;
+    let flexItems = columns.map((column, index)=>{
+        var _column_width, _ref, _ref1;
+        let width = changedColumns.get(column.key) != null ? changedColumns.get(column.key) : (_ref1 = (_ref = (_column_width = column.width) !== null && _column_width !== void 0 ? _column_width : column.defaultWidth) !== null && _ref !== void 0 ? _ref : getDefaultWidth === null || getDefaultWidth === void 0 ? void 0 : getDefaultWidth(index)) !== null && _ref1 !== void 0 ? _ref1 : "1fr";
+        let frozen = false;
+        let baseSize = 0;
+        let flex = 0;
+        let targetMainSize = null;
+        if ($9e5f6a0caf75716e$export$1994a077b98ee0d5(width)) {
+            baseSize = $9e5f6a0caf75716e$export$7bbad27896f7ae9f(width, availableWidth);
+            frozen = true;
+        } else {
+            flex = $9e5f6a0caf75716e$export$9078bad4c3934604(width);
+            if (flex <= 0) frozen = true;
+        }
+        var _column_minWidth, _ref2;
+        let min = $9e5f6a0caf75716e$export$f556054ce4358701((_ref2 = (_column_minWidth = column.minWidth) !== null && _column_minWidth !== void 0 ? _column_minWidth : getDefaultMinWidth === null || getDefaultMinWidth === void 0 ? void 0 : getDefaultMinWidth(index)) !== null && _ref2 !== void 0 ? _ref2 : 0, availableWidth);
+        let max = $9e5f6a0caf75716e$export$59185c62a7544aa0(column.maxWidth, availableWidth);
+        let hypotheticalMainSize = Math.max(min, Math.min(baseSize, max));
+        // 9.7.1
+        // We don't make use of flex basis, it's always 0, so we are always in 'grow' mode.
+        // 9.7.2
+        if (frozen) targetMainSize = hypotheticalMainSize;
+        else if (baseSize > hypotheticalMainSize) {
+            frozen = true;
+            targetMainSize = hypotheticalMainSize;
+        }
+        // 9.7.3
+        if (!frozen) hasNonFrozenItems = true;
+        return {
+            frozen: frozen,
+            baseSize: baseSize,
+            hypotheticalMainSize: hypotheticalMainSize,
+            min: min,
+            max: max,
+            flex: flex,
+            targetMainSize: targetMainSize,
+            violation: 0
+        };
+    });
+    // 9.7.4
+    // 9.7.4.a
+    while(hasNonFrozenItems){
+        // 9.7.4.b
+        /**
+     * Calculate the remaining free space as for initial free space,
+     * above (9.7.3). If the sum of the unfrozen flex items’ flex factors is
+     * less than one, multiply the initial free space by this sum (of flex factors).
+     * If the magnitude of this value is less than the magnitude of
+     * the remaining free space, use this as the remaining free space.
+     */ let usedWidth = 0;
+        let flexFactors = 0;
+        flexItems.forEach((item)=>{
+            if (item.frozen) usedWidth += item.targetMainSize;
+            else {
+                usedWidth += item.baseSize;
+                flexFactors += item.flex;
+            }
+        });
+        let remainingFreeSpace = availableWidth - usedWidth;
+        // we only support integer FR's, and because of hasNonFrozenItems, we know that flexFactors > 0
+        // so no need to check for flexFactors < 1
+        // 9.7.4.c
+        /**
+     * If the remaining free space is zero
+     * - Do nothing.
+     * Else // remember, we're always in grow mode
+     * - Find the ratio of the item’s flex grow factor to the
+     * sum of the flex grow factors of all unfrozen items on
+     * the line. Set the item’s target main size to its flex
+     * base size plus a fraction of the remaining free space
+     * proportional to the ratio.
+     */ if (remainingFreeSpace > 0) flexItems.forEach((item)=>{
+            if (!item.frozen) {
+                let ratio = item.flex / flexFactors;
+                item.targetMainSize = item.baseSize + ratio * remainingFreeSpace;
+            }
+        });
+        // 9.7.4.d
+        /**
+     * Fix min/max violations. Clamp each non-frozen item’s
+     * target main size by its used min and max main sizes
+     * and floor its content-box size at zero. If the item’s
+     * target main size was made smaller by this, it’s a max
+     * violation. If the item’s target main size was made
+     * larger by this, it’s a min violation.
+     */ let totalViolation = 0;
+        flexItems.forEach((item)=>{
+            item.violation = 0;
+            if (!item.frozen) {
+                let { min: min, max: max, targetMainSize: targetMainSize } = item;
+                item.targetMainSize = Math.max(min, Math.min(targetMainSize, max));
+                item.violation = item.targetMainSize - targetMainSize;
+                totalViolation += item.violation;
+            }
+        });
+        // 9.7.4.e
+        /**
+     * Freeze over-flexed items. The total violation is the
+     * sum of the adjustments from the previous step
+     * ∑(clamped size - unclamped size). If the total violation is:
+     * Zero
+     * - Freeze all items.
+     *
+     * Positive
+     * - Freeze all the items with min violations.
+     *
+     * Negative
+     * - Freeze all the items with max violations.
+     */ hasNonFrozenItems = false;
+        flexItems.forEach((item)=>{
+            if (totalViolation === 0 || Math.sign(totalViolation) === Math.sign(item.violation)) item.frozen = true;
+            else if (!item.frozen) hasNonFrozenItems = true;
+        });
+    }
+    return $9e5f6a0caf75716e$var$cascadeRounding(flexItems);
+}
+function $9e5f6a0caf75716e$var$cascadeRounding(flexItems) {
+    /*
+  Given an array of floats that sum to an integer, this rounds the floats
+  and returns an array of integers with the same sum.
+  */ let fpTotal = 0;
+    let intTotal = 0;
+    let roundedArray = [];
+    flexItems.forEach(function(item) {
+        let float = item.targetMainSize;
+        let integer = Math.round(float + fpTotal) - intTotal;
+        fpTotal += float;
+        intTotal += integer;
+        roundedArray.push(integer);
+    });
+    return roundedArray;
+}
+
+
+//# sourceMappingURL=TableUtils.main.js.map

package/dist/TableUtils.main.js.map

@@ -0,0 +1 @@
+{"mappings":"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","sources":["packages/@react-stately/table/src/TableUtils.ts"],"sourcesContent":["/*\n * Copyright 2022 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {ColumnSize} from '@react-types/table';\nimport {Key} from '@react-types/shared';\n\n// numbers and percents are considered static. *fr units or a lack of units are considered dynamic.\nexport function isStatic(width: number | string): boolean {\n  return width != null && (!isNaN(width as number) || (String(width)).match(/^(\\d+)(?=%$)/) !== null);\n}\n\nexport function parseFractionalUnit(width: string): number {\n  if (!width) {\n    return 1;\n  }\n  let match = width.match(/^(.+)(?=fr$)/);\n  // if width is the incorrect format, just default it to a 1fr\n  if (!match) {\n    console.warn(`width: ${width} is not a supported format, width should be a number (ex. 150), percentage (ex. '50%') or fr unit (ex. '2fr')`,\n      'defaulting to \\'1fr\\'');\n    return 1;\n  }\n  return parseFloat(match[0]);\n}\n\nexport function parseStaticWidth(width: number | string, tableWidth: number): number {\n  if (typeof width === 'string') {\n    let match = width.match(/^(\\d+)(?=%$)/);\n    if (!match) {\n      throw new Error('Only percentages or numbers are supported for static column widths');\n    }\n    return tableWidth * (parseFloat(match[0]) / 100);\n  }\n  return width;\n}\n\n\nexport function getMaxWidth(maxWidth: number | string, tableWidth: number): number {\n  return maxWidth != null\n    ? parseStaticWidth(maxWidth, tableWidth)\n    : Number.MAX_SAFE_INTEGER;\n}\n\n// cannot support FR units, we'd need to know everything else in the table to do that\nexport function getMinWidth(minWidth: number | string, tableWidth: number): number {\n  return minWidth != null\n    ? parseStaticWidth(minWidth, tableWidth)\n    : 0;\n}\n\n\nexport interface IColumn {\n  minWidth?: number | string,\n  maxWidth?: number | string,\n  width?: number | string,\n  defaultWidth?: number | string,\n  key?: Key\n}\n\n/**\n * Implements the flex algorithm described in https://www.w3.org/TR/css-flexbox-1/#layout-algorithm\n * It makes a few constraint/assumptions:\n * 1. All basis values are 0 unless it is a static width, then the basis is the static width\n * 2. All flex grow and shrink values are equal to the FR specified on the column, grow and shrink for the same column are equal\n * 3. We only have one row\n * An example of the setup can be seen here https://jsfiddle.net/snowystinger/wv0ymjaf/61/ where I let the browser figure out the\n * flex of the columns.\n * Note: We differ in one key aspect, all of our column widths must be whole numbers, so we avoid browser\n * sub pixel rounding errors. To do this, we use a cascading rounding algorithm to ensure that the sum of the widths is maintained\n * while distributing the rounding remainder across the columns.\n *\n * As noted in the chrome source code, this algorithm is very accurate, but has the potential to be quadratic.\n * They have deemed this to be acceptable because the number of elements is usually small and the flex factors\n * are usually not high variance. I believe we can make the same assumptions. Particularly once resizing is\n * started, it will convert all columns to the left to static widths, so it will cut down on the number of FR columns.\n *\n * There are likely faster ways to do this, I've chosen to stick to the spec as closely as possible for readability, accuracy, and for the\n * note that this behaving quadratically is unlikely to be a problem.\n * @param availableWidth - The visible width of the table.\n * @param columns - The table defined columns.\n * @param changedColumns - Any columns we want to override, for example, during resizing.\n * @param getDefaultWidth - A function that returns the default width of a column by its index.\n * @param getDefaultMinWidth - A function that returns the default min width of a column by its index.\n */\nexport function calculateColumnSizes(availableWidth: number, columns: IColumn[], changedColumns: Map<Key, ColumnSize>, getDefaultWidth, getDefaultMinWidth) {\n  let hasNonFrozenItems = false;\n  let flexItems = columns.map((column, index) => {\n    let width = changedColumns.get(column.key) != null ? changedColumns.get(column.key) : column.width ?? column.defaultWidth ?? getDefaultWidth?.(index) ?? '1fr';\n    let frozen = false;\n    let baseSize = 0;\n    let flex = 0;\n    let targetMainSize = null;\n    if (isStatic(width)) {\n      baseSize = parseStaticWidth(width, availableWidth);\n      frozen = true;\n    } else {\n      flex = parseFractionalUnit(width);\n      if (flex <= 0) {\n        frozen = true;\n      }\n    }\n\n    let min = getMinWidth(column.minWidth ?? getDefaultMinWidth?.(index) ?? 0, availableWidth);\n    let max = getMaxWidth(column.maxWidth, availableWidth);\n    let hypotheticalMainSize = Math.max(min, Math.min(baseSize, max));\n\n    // 9.7.1\n    // We don't make use of flex basis, it's always 0, so we are always in 'grow' mode.\n    // 9.7.2\n    if (frozen) {\n      targetMainSize = hypotheticalMainSize;\n    } else if (baseSize > hypotheticalMainSize) {\n      frozen = true;\n      targetMainSize = hypotheticalMainSize;\n    }\n\n    // 9.7.3\n    if (!frozen) {\n      hasNonFrozenItems = true;\n    }\n    return {\n      frozen,\n      baseSize,\n      hypotheticalMainSize,\n      min,\n      max,\n      flex,\n      targetMainSize,\n      violation: 0\n    };\n  });\n\n  // 9.7.4\n  // 9.7.4.a\n  while (hasNonFrozenItems) {\n    // 9.7.4.b\n    /**\n     * Calculate the remaining free space as for initial free space,\n     * above (9.7.3). If the sum of the unfrozen flex items’ flex factors is\n     * less than one, multiply the initial free space by this sum (of flex factors).\n     * If the magnitude of this value is less than the magnitude of\n     * the remaining free space, use this as the remaining free space.\n     */\n    let usedWidth = 0;\n    let flexFactors = 0;\n    flexItems.forEach(item => {\n      if (item.frozen) {\n        usedWidth += item.targetMainSize;\n      } else {\n        usedWidth += item.baseSize;\n        flexFactors += item.flex;\n      }\n    });\n\n    let remainingFreeSpace = availableWidth - usedWidth;\n    // we only support integer FR's, and because of hasNonFrozenItems, we know that flexFactors > 0\n    // so no need to check for flexFactors < 1\n    // 9.7.4.c\n    /**\n     * If the remaining free space is zero\n     * - Do nothing.\n     * Else // remember, we're always in grow mode\n     * - Find the ratio of the item’s flex grow factor to the\n     * sum of the flex grow factors of all unfrozen items on\n     * the line. Set the item’s target main size to its flex\n     * base size plus a fraction of the remaining free space\n     * proportional to the ratio.\n     */\n    if (remainingFreeSpace > 0) {\n      flexItems.forEach((item) => {\n        if (!item.frozen) {\n          let ratio = item.flex / flexFactors;\n          item.targetMainSize = item.baseSize + (ratio * remainingFreeSpace);\n        }\n      });\n    }\n\n    // 9.7.4.d\n    /**\n     * Fix min/max violations. Clamp each non-frozen item’s\n     * target main size by its used min and max main sizes\n     * and floor its content-box size at zero. If the item’s\n     * target main size was made smaller by this, it’s a max\n     * violation. If the item’s target main size was made\n     * larger by this, it’s a min violation.\n     */\n    let totalViolation = 0;\n    flexItems.forEach(item => {\n      item.violation = 0;\n      if (!item.frozen) {\n        let {min, max, targetMainSize} = item;\n        item.targetMainSize = Math.max(min, Math.min(targetMainSize, max));\n\n        item.violation = item.targetMainSize - targetMainSize;\n        totalViolation += item.violation;\n      }\n    });\n\n    // 9.7.4.e\n    /**\n     * Freeze over-flexed items. The total violation is the\n     * sum of the adjustments from the previous step\n     * ∑(clamped size - unclamped size). If the total violation is:\n     * Zero\n     * - Freeze all items.\n     *\n     * Positive\n     * - Freeze all the items with min violations.\n     *\n     * Negative\n     * - Freeze all the items with max violations.\n     */\n    hasNonFrozenItems = false;\n    flexItems.forEach(item => {\n      if (totalViolation === 0 || Math.sign(totalViolation) === Math.sign(item.violation)) {\n        item.frozen = true;\n      } else if (!item.frozen) {\n        hasNonFrozenItems = true;\n      }\n    });\n  }\n\n  return cascadeRounding(flexItems);\n}\n\nfunction cascadeRounding(flexItems): number[] {\n  /*\n  Given an array of floats that sum to an integer, this rounds the floats\n  and returns an array of integers with the same sum.\n  */\n\n  let fpTotal = 0;\n  let intTotal = 0;\n  let roundedArray = [];\n  flexItems.forEach(function (item) {\n    let float = item.targetMainSize;\n    let integer = Math.round(float + fpTotal) - intTotal;\n    fpTotal += float;\n    intTotal += integer;\n    roundedArray.push(integer);\n  });\n\n  return roundedArray;\n}\n"],"names":[],"version":3,"file":"TableUtils.main.js.map"}

package/dist/TableUtils.mjs

@@ -0,0 +1,175 @@
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ function $6818b1c4fc67028d$export$1994a077b98ee0d5(width) {
+    return width != null && (!isNaN(width) || String(width).match(/^(\d+)(?=%$)/) !== null);
+}
+function $6818b1c4fc67028d$export$9078bad4c3934604(width) {
+    if (!width) return 1;
+    let match = width.match(/^(.+)(?=fr$)/);
+    // if width is the incorrect format, just default it to a 1fr
+    if (!match) {
+        console.warn(`width: ${width} is not a supported format, width should be a number (ex. 150), percentage (ex. '50%') or fr unit (ex. '2fr')`, "defaulting to '1fr'");
+        return 1;
+    }
+    return parseFloat(match[0]);
+}
+function $6818b1c4fc67028d$export$7bbad27896f7ae9f(width, tableWidth) {
+    if (typeof width === "string") {
+        let match = width.match(/^(\d+)(?=%$)/);
+        if (!match) throw new Error("Only percentages or numbers are supported for static column widths");
+        return tableWidth * (parseFloat(match[0]) / 100);
+    }
+    return width;
+}
+function $6818b1c4fc67028d$export$59185c62a7544aa0(maxWidth, tableWidth) {
+    return maxWidth != null ? $6818b1c4fc67028d$export$7bbad27896f7ae9f(maxWidth, tableWidth) : Number.MAX_SAFE_INTEGER;
+}
+function $6818b1c4fc67028d$export$f556054ce4358701(minWidth, tableWidth) {
+    return minWidth != null ? $6818b1c4fc67028d$export$7bbad27896f7ae9f(minWidth, tableWidth) : 0;
+}
+function $6818b1c4fc67028d$export$55d50dc687385491(availableWidth, columns, changedColumns, getDefaultWidth, getDefaultMinWidth) {
+    let hasNonFrozenItems = false;
+    let flexItems = columns.map((column, index)=>{
+        var _column_width, _ref, _ref1;
+        let width = changedColumns.get(column.key) != null ? changedColumns.get(column.key) : (_ref1 = (_ref = (_column_width = column.width) !== null && _column_width !== void 0 ? _column_width : column.defaultWidth) !== null && _ref !== void 0 ? _ref : getDefaultWidth === null || getDefaultWidth === void 0 ? void 0 : getDefaultWidth(index)) !== null && _ref1 !== void 0 ? _ref1 : "1fr";
+        let frozen = false;
+        let baseSize = 0;
+        let flex = 0;
+        let targetMainSize = null;
+        if ($6818b1c4fc67028d$export$1994a077b98ee0d5(width)) {
+            baseSize = $6818b1c4fc67028d$export$7bbad27896f7ae9f(width, availableWidth);
+            frozen = true;
+        } else {
+            flex = $6818b1c4fc67028d$export$9078bad4c3934604(width);
+            if (flex <= 0) frozen = true;
+        }
+        var _column_minWidth, _ref2;
+        let min = $6818b1c4fc67028d$export$f556054ce4358701((_ref2 = (_column_minWidth = column.minWidth) !== null && _column_minWidth !== void 0 ? _column_minWidth : getDefaultMinWidth === null || getDefaultMinWidth === void 0 ? void 0 : getDefaultMinWidth(index)) !== null && _ref2 !== void 0 ? _ref2 : 0, availableWidth);
+        let max = $6818b1c4fc67028d$export$59185c62a7544aa0(column.maxWidth, availableWidth);
+        let hypotheticalMainSize = Math.max(min, Math.min(baseSize, max));
+        // 9.7.1
+        // We don't make use of flex basis, it's always 0, so we are always in 'grow' mode.
+        // 9.7.2
+        if (frozen) targetMainSize = hypotheticalMainSize;
+        else if (baseSize > hypotheticalMainSize) {
+            frozen = true;
+            targetMainSize = hypotheticalMainSize;
+        }
+        // 9.7.3
+        if (!frozen) hasNonFrozenItems = true;
+        return {
+            frozen: frozen,
+            baseSize: baseSize,
+            hypotheticalMainSize: hypotheticalMainSize,
+            min: min,
+            max: max,
+            flex: flex,
+            targetMainSize: targetMainSize,
+            violation: 0
+        };
+    });
+    // 9.7.4
+    // 9.7.4.a
+    while(hasNonFrozenItems){
+        // 9.7.4.b
+        /**
+     * Calculate the remaining free space as for initial free space,
+     * above (9.7.3). If the sum of the unfrozen flex items’ flex factors is
+     * less than one, multiply the initial free space by this sum (of flex factors).
+     * If the magnitude of this value is less than the magnitude of
+     * the remaining free space, use this as the remaining free space.
+     */ let usedWidth = 0;
+        let flexFactors = 0;
+        flexItems.forEach((item)=>{
+            if (item.frozen) usedWidth += item.targetMainSize;
+            else {
+                usedWidth += item.baseSize;
+                flexFactors += item.flex;
+            }
+        });
+        let remainingFreeSpace = availableWidth - usedWidth;
+        // we only support integer FR's, and because of hasNonFrozenItems, we know that flexFactors > 0
+        // so no need to check for flexFactors < 1
+        // 9.7.4.c
+        /**
+     * If the remaining free space is zero
+     * - Do nothing.
+     * Else // remember, we're always in grow mode
+     * - Find the ratio of the item’s flex grow factor to the
+     * sum of the flex grow factors of all unfrozen items on
+     * the line. Set the item’s target main size to its flex
+     * base size plus a fraction of the remaining free space
+     * proportional to the ratio.
+     */ if (remainingFreeSpace > 0) flexItems.forEach((item)=>{
+            if (!item.frozen) {
+                let ratio = item.flex / flexFactors;
+                item.targetMainSize = item.baseSize + ratio * remainingFreeSpace;
+            }
+        });
+        // 9.7.4.d
+        /**
+     * Fix min/max violations. Clamp each non-frozen item’s
+     * target main size by its used min and max main sizes
+     * and floor its content-box size at zero. If the item’s
+     * target main size was made smaller by this, it’s a max
+     * violation. If the item’s target main size was made
+     * larger by this, it’s a min violation.
+     */ let totalViolation = 0;
+        flexItems.forEach((item)=>{
+            item.violation = 0;
+            if (!item.frozen) {
+                let { min: min, max: max, targetMainSize: targetMainSize } = item;
+                item.targetMainSize = Math.max(min, Math.min(targetMainSize, max));
+                item.violation = item.targetMainSize - targetMainSize;
+                totalViolation += item.violation;
+            }
+        });
+        // 9.7.4.e
+        /**
+     * Freeze over-flexed items. The total violation is the
+     * sum of the adjustments from the previous step
+     * ∑(clamped size - unclamped size). If the total violation is:
+     * Zero
+     * - Freeze all items.
+     *
+     * Positive
+     * - Freeze all the items with min violations.
+     *
+     * Negative
+     * - Freeze all the items with max violations.
+     */ hasNonFrozenItems = false;
+        flexItems.forEach((item)=>{
+            if (totalViolation === 0 || Math.sign(totalViolation) === Math.sign(item.violation)) item.frozen = true;
+            else if (!item.frozen) hasNonFrozenItems = true;
+        });
+    }
+    return $6818b1c4fc67028d$var$cascadeRounding(flexItems);
+}
+function $6818b1c4fc67028d$var$cascadeRounding(flexItems) {
+    /*
+  Given an array of floats that sum to an integer, this rounds the floats
+  and returns an array of integers with the same sum.
+  */ let fpTotal = 0;
+    let intTotal = 0;
+    let roundedArray = [];
+    flexItems.forEach(function(item) {
+        let float = item.targetMainSize;
+        let integer = Math.round(float + fpTotal) - intTotal;
+        fpTotal += float;
+        intTotal += integer;
+        roundedArray.push(integer);
+    });
+    return roundedArray;
+}
+
+
+export {$6818b1c4fc67028d$export$1994a077b98ee0d5 as isStatic, $6818b1c4fc67028d$export$9078bad4c3934604 as parseFractionalUnit, $6818b1c4fc67028d$export$7bbad27896f7ae9f as parseStaticWidth, $6818b1c4fc67028d$export$59185c62a7544aa0 as getMaxWidth, $6818b1c4fc67028d$export$f556054ce4358701 as getMinWidth, $6818b1c4fc67028d$export$55d50dc687385491 as calculateColumnSizes};
+//# sourceMappingURL=TableUtils.mjs.map

package/dist/TableUtils.module.js

@@ -0,0 +1,175 @@
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ function $6818b1c4fc67028d$export$1994a077b98ee0d5(width) {
+    return width != null && (!isNaN(width) || String(width).match(/^(\d+)(?=%$)/) !== null);
+}
+function $6818b1c4fc67028d$export$9078bad4c3934604(width) {
+    if (!width) return 1;
+    let match = width.match(/^(.+)(?=fr$)/);
+    // if width is the incorrect format, just default it to a 1fr
+    if (!match) {
+        console.warn(`width: ${width} is not a supported format, width should be a number (ex. 150), percentage (ex. '50%') or fr unit (ex. '2fr')`, "defaulting to '1fr'");
+        return 1;
+    }
+    return parseFloat(match[0]);
+}
+function $6818b1c4fc67028d$export$7bbad27896f7ae9f(width, tableWidth) {
+    if (typeof width === "string") {
+        let match = width.match(/^(\d+)(?=%$)/);
+        if (!match) throw new Error("Only percentages or numbers are supported for static column widths");
+        return tableWidth * (parseFloat(match[0]) / 100);
+    }
+    return width;
+}
+function $6818b1c4fc67028d$export$59185c62a7544aa0(maxWidth, tableWidth) {
+    return maxWidth != null ? $6818b1c4fc67028d$export$7bbad27896f7ae9f(maxWidth, tableWidth) : Number.MAX_SAFE_INTEGER;
+}
+function $6818b1c4fc67028d$export$f556054ce4358701(minWidth, tableWidth) {
+    return minWidth != null ? $6818b1c4fc67028d$export$7bbad27896f7ae9f(minWidth, tableWidth) : 0;
+}
+function $6818b1c4fc67028d$export$55d50dc687385491(availableWidth, columns, changedColumns, getDefaultWidth, getDefaultMinWidth) {
+    let hasNonFrozenItems = false;
+    let flexItems = columns.map((column, index)=>{
+        var _column_width, _ref, _ref1;
+        let width = changedColumns.get(column.key) != null ? changedColumns.get(column.key) : (_ref1 = (_ref = (_column_width = column.width) !== null && _column_width !== void 0 ? _column_width : column.defaultWidth) !== null && _ref !== void 0 ? _ref : getDefaultWidth === null || getDefaultWidth === void 0 ? void 0 : getDefaultWidth(index)) !== null && _ref1 !== void 0 ? _ref1 : "1fr";
+        let frozen = false;
+        let baseSize = 0;
+        let flex = 0;
+        let targetMainSize = null;
+        if ($6818b1c4fc67028d$export$1994a077b98ee0d5(width)) {
+            baseSize = $6818b1c4fc67028d$export$7bbad27896f7ae9f(width, availableWidth);
+            frozen = true;
+        } else {
+            flex = $6818b1c4fc67028d$export$9078bad4c3934604(width);
+            if (flex <= 0) frozen = true;
+        }
+        var _column_minWidth, _ref2;
+        let min = $6818b1c4fc67028d$export$f556054ce4358701((_ref2 = (_column_minWidth = column.minWidth) !== null && _column_minWidth !== void 0 ? _column_minWidth : getDefaultMinWidth === null || getDefaultMinWidth === void 0 ? void 0 : getDefaultMinWidth(index)) !== null && _ref2 !== void 0 ? _ref2 : 0, availableWidth);
+        let max = $6818b1c4fc67028d$export$59185c62a7544aa0(column.maxWidth, availableWidth);
+        let hypotheticalMainSize = Math.max(min, Math.min(baseSize, max));
+        // 9.7.1
+        // We don't make use of flex basis, it's always 0, so we are always in 'grow' mode.
+        // 9.7.2
+        if (frozen) targetMainSize = hypotheticalMainSize;
+        else if (baseSize > hypotheticalMainSize) {
+            frozen = true;
+            targetMainSize = hypotheticalMainSize;
+        }
+        // 9.7.3
+        if (!frozen) hasNonFrozenItems = true;
+        return {
+            frozen: frozen,
+            baseSize: baseSize,
+            hypotheticalMainSize: hypotheticalMainSize,
+            min: min,
+            max: max,
+            flex: flex,
+            targetMainSize: targetMainSize,
+            violation: 0
+        };
+    });
+    // 9.7.4
+    // 9.7.4.a
+    while(hasNonFrozenItems){
+        // 9.7.4.b
+        /**
+     * Calculate the remaining free space as for initial free space,
+     * above (9.7.3). If the sum of the unfrozen flex items’ flex factors is
+     * less than one, multiply the initial free space by this sum (of flex factors).
+     * If the magnitude of this value is less than the magnitude of
+     * the remaining free space, use this as the remaining free space.
+     */ let usedWidth = 0;
+        let flexFactors = 0;
+        flexItems.forEach((item)=>{
+            if (item.frozen) usedWidth += item.targetMainSize;
+            else {
+                usedWidth += item.baseSize;
+                flexFactors += item.flex;
+            }
+        });
+        let remainingFreeSpace = availableWidth - usedWidth;
+        // we only support integer FR's, and because of hasNonFrozenItems, we know that flexFactors > 0
+        // so no need to check for flexFactors < 1
+        // 9.7.4.c
+        /**
+     * If the remaining free space is zero
+     * - Do nothing.
+     * Else // remember, we're always in grow mode
+     * - Find the ratio of the item’s flex grow factor to the
+     * sum of the flex grow factors of all unfrozen items on
+     * the line. Set the item’s target main size to its flex
+     * base size plus a fraction of the remaining free space
+     * proportional to the ratio.
+     */ if (remainingFreeSpace > 0) flexItems.forEach((item)=>{
+            if (!item.frozen) {
+                let ratio = item.flex / flexFactors;
+                item.targetMainSize = item.baseSize + ratio * remainingFreeSpace;
+            }
+        });
+        // 9.7.4.d
+        /**
+     * Fix min/max violations. Clamp each non-frozen item’s
+     * target main size by its used min and max main sizes
+     * and floor its content-box size at zero. If the item’s
+     * target main size was made smaller by this, it’s a max
+     * violation. If the item’s target main size was made
+     * larger by this, it’s a min violation.
+     */ let totalViolation = 0;
+        flexItems.forEach((item)=>{
+            item.violation = 0;
+            if (!item.frozen) {
+                let { min: min, max: max, targetMainSize: targetMainSize } = item;
+                item.targetMainSize = Math.max(min, Math.min(targetMainSize, max));
+                item.violation = item.targetMainSize - targetMainSize;
+                totalViolation += item.violation;
+            }
+        });
+        // 9.7.4.e
+        /**
+     * Freeze over-flexed items. The total violation is the
+     * sum of the adjustments from the previous step
+     * ∑(clamped size - unclamped size). If the total violation is:
+     * Zero
+     * - Freeze all items.
+     *
+     * Positive
+     * - Freeze all the items with min violations.
+     *
+     * Negative
+     * - Freeze all the items with max violations.
+     */ hasNonFrozenItems = false;
+        flexItems.forEach((item)=>{
+            if (totalViolation === 0 || Math.sign(totalViolation) === Math.sign(item.violation)) item.frozen = true;
+            else if (!item.frozen) hasNonFrozenItems = true;
+        });
+    }
+    return $6818b1c4fc67028d$var$cascadeRounding(flexItems);
+}
+function $6818b1c4fc67028d$var$cascadeRounding(flexItems) {
+    /*
+  Given an array of floats that sum to an integer, this rounds the floats
+  and returns an array of integers with the same sum.
+  */ let fpTotal = 0;
+    let intTotal = 0;
+    let roundedArray = [];
+    flexItems.forEach(function(item) {
+        let float = item.targetMainSize;
+        let integer = Math.round(float + fpTotal) - intTotal;
+        fpTotal += float;
+        intTotal += integer;
+        roundedArray.push(integer);
+    });
+    return roundedArray;
+}
+
+
+export {$6818b1c4fc67028d$export$1994a077b98ee0d5 as isStatic, $6818b1c4fc67028d$export$9078bad4c3934604 as parseFractionalUnit, $6818b1c4fc67028d$export$7bbad27896f7ae9f as parseStaticWidth, $6818b1c4fc67028d$export$59185c62a7544aa0 as getMaxWidth, $6818b1c4fc67028d$export$f556054ce4358701 as getMinWidth, $6818b1c4fc67028d$export$55d50dc687385491 as calculateColumnSizes};
+//# sourceMappingURL=TableUtils.module.js.map

package/dist/TableUtils.module.js.map

@@ -0,0 +1 @@
+{"mappings":"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","sources":["packages/@react-stately/table/src/TableUtils.ts"],"sourcesContent":["/*\n * Copyright 2022 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {ColumnSize} from '@react-types/table';\nimport {Key} from '@react-types/shared';\n\n// numbers and percents are considered static. *fr units or a lack of units are considered dynamic.\nexport function isStatic(width: number | string): boolean {\n  return width != null && (!isNaN(width as number) || (String(width)).match(/^(\\d+)(?=%$)/) !== null);\n}\n\nexport function parseFractionalUnit(width: string): number {\n  if (!width) {\n    return 1;\n  }\n  let match = width.match(/^(.+)(?=fr$)/);\n  // if width is the incorrect format, just default it to a 1fr\n  if (!match) {\n    console.warn(`width: ${width} is not a supported format, width should be a number (ex. 150), percentage (ex. '50%') or fr unit (ex. '2fr')`,\n      'defaulting to \\'1fr\\'');\n    return 1;\n  }\n  return parseFloat(match[0]);\n}\n\nexport function parseStaticWidth(width: number | string, tableWidth: number): number {\n  if (typeof width === 'string') {\n    let match = width.match(/^(\\d+)(?=%$)/);\n    if (!match) {\n      throw new Error('Only percentages or numbers are supported for static column widths');\n    }\n    return tableWidth * (parseFloat(match[0]) / 100);\n  }\n  return width;\n}\n\n\nexport function getMaxWidth(maxWidth: number | string, tableWidth: number): number {\n  return maxWidth != null\n    ? parseStaticWidth(maxWidth, tableWidth)\n    : Number.MAX_SAFE_INTEGER;\n}\n\n// cannot support FR units, we'd need to know everything else in the table to do that\nexport function getMinWidth(minWidth: number | string, tableWidth: number): number {\n  return minWidth != null\n    ? parseStaticWidth(minWidth, tableWidth)\n    : 0;\n}\n\n\nexport interface IColumn {\n  minWidth?: number | string,\n  maxWidth?: number | string,\n  width?: number | string,\n  defaultWidth?: number | string,\n  key?: Key\n}\n\n/**\n * Implements the flex algorithm described in https://www.w3.org/TR/css-flexbox-1/#layout-algorithm\n * It makes a few constraint/assumptions:\n * 1. All basis values are 0 unless it is a static width, then the basis is the static width\n * 2. All flex grow and shrink values are equal to the FR specified on the column, grow and shrink for the same column are equal\n * 3. We only have one row\n * An example of the setup can be seen here https://jsfiddle.net/snowystinger/wv0ymjaf/61/ where I let the browser figure out the\n * flex of the columns.\n * Note: We differ in one key aspect, all of our column widths must be whole numbers, so we avoid browser\n * sub pixel rounding errors. To do this, we use a cascading rounding algorithm to ensure that the sum of the widths is maintained\n * while distributing the rounding remainder across the columns.\n *\n * As noted in the chrome source code, this algorithm is very accurate, but has the potential to be quadratic.\n * They have deemed this to be acceptable because the number of elements is usually small and the flex factors\n * are usually not high variance. I believe we can make the same assumptions. Particularly once resizing is\n * started, it will convert all columns to the left to static widths, so it will cut down on the number of FR columns.\n *\n * There are likely faster ways to do this, I've chosen to stick to the spec as closely as possible for readability, accuracy, and for the\n * note that this behaving quadratically is unlikely to be a problem.\n * @param availableWidth - The visible width of the table.\n * @param columns - The table defined columns.\n * @param changedColumns - Any columns we want to override, for example, during resizing.\n * @param getDefaultWidth - A function that returns the default width of a column by its index.\n * @param getDefaultMinWidth - A function that returns the default min width of a column by its index.\n */\nexport function calculateColumnSizes(availableWidth: number, columns: IColumn[], changedColumns: Map<Key, ColumnSize>, getDefaultWidth, getDefaultMinWidth) {\n  let hasNonFrozenItems = false;\n  let flexItems = columns.map((column, index) => {\n    let width = changedColumns.get(column.key) != null ? changedColumns.get(column.key) : column.width ?? column.defaultWidth ?? getDefaultWidth?.(index) ?? '1fr';\n    let frozen = false;\n    let baseSize = 0;\n    let flex = 0;\n    let targetMainSize = null;\n    if (isStatic(width)) {\n      baseSize = parseStaticWidth(width, availableWidth);\n      frozen = true;\n    } else {\n      flex = parseFractionalUnit(width);\n      if (flex <= 0) {\n        frozen = true;\n      }\n    }\n\n    let min = getMinWidth(column.minWidth ?? getDefaultMinWidth?.(index) ?? 0, availableWidth);\n    let max = getMaxWidth(column.maxWidth, availableWidth);\n    let hypotheticalMainSize = Math.max(min, Math.min(baseSize, max));\n\n    // 9.7.1\n    // We don't make use of flex basis, it's always 0, so we are always in 'grow' mode.\n    // 9.7.2\n    if (frozen) {\n      targetMainSize = hypotheticalMainSize;\n    } else if (baseSize > hypotheticalMainSize) {\n      frozen = true;\n      targetMainSize = hypotheticalMainSize;\n    }\n\n    // 9.7.3\n    if (!frozen) {\n      hasNonFrozenItems = true;\n    }\n    return {\n      frozen,\n      baseSize,\n      hypotheticalMainSize,\n      min,\n      max,\n      flex,\n      targetMainSize,\n      violation: 0\n    };\n  });\n\n  // 9.7.4\n  // 9.7.4.a\n  while (hasNonFrozenItems) {\n    // 9.7.4.b\n    /**\n     * Calculate the remaining free space as for initial free space,\n     * above (9.7.3). If the sum of the unfrozen flex items’ flex factors is\n     * less than one, multiply the initial free space by this sum (of flex factors).\n     * If the magnitude of this value is less than the magnitude of\n     * the remaining free space, use this as the remaining free space.\n     */\n    let usedWidth = 0;\n    let flexFactors = 0;\n    flexItems.forEach(item => {\n      if (item.frozen) {\n        usedWidth += item.targetMainSize;\n      } else {\n        usedWidth += item.baseSize;\n        flexFactors += item.flex;\n      }\n    });\n\n    let remainingFreeSpace = availableWidth - usedWidth;\n    // we only support integer FR's, and because of hasNonFrozenItems, we know that flexFactors > 0\n    // so no need to check for flexFactors < 1\n    // 9.7.4.c\n    /**\n     * If the remaining free space is zero\n     * - Do nothing.\n     * Else // remember, we're always in grow mode\n     * - Find the ratio of the item’s flex grow factor to the\n     * sum of the flex grow factors of all unfrozen items on\n     * the line. Set the item’s target main size to its flex\n     * base size plus a fraction of the remaining free space\n     * proportional to the ratio.\n     */\n    if (remainingFreeSpace > 0) {\n      flexItems.forEach((item) => {\n        if (!item.frozen) {\n          let ratio = item.flex / flexFactors;\n          item.targetMainSize = item.baseSize + (ratio * remainingFreeSpace);\n        }\n      });\n    }\n\n    // 9.7.4.d\n    /**\n     * Fix min/max violations. Clamp each non-frozen item’s\n     * target main size by its used min and max main sizes\n     * and floor its content-box size at zero. If the item’s\n     * target main size was made smaller by this, it’s a max\n     * violation. If the item’s target main size was made\n     * larger by this, it’s a min violation.\n     */\n    let totalViolation = 0;\n    flexItems.forEach(item => {\n      item.violation = 0;\n      if (!item.frozen) {\n        let {min, max, targetMainSize} = item;\n        item.targetMainSize = Math.max(min, Math.min(targetMainSize, max));\n\n        item.violation = item.targetMainSize - targetMainSize;\n        totalViolation += item.violation;\n      }\n    });\n\n    // 9.7.4.e\n    /**\n     * Freeze over-flexed items. The total violation is the\n     * sum of the adjustments from the previous step\n     * ∑(clamped size - unclamped size). If the total violation is:\n     * Zero\n     * - Freeze all items.\n     *\n     * Positive\n     * - Freeze all the items with min violations.\n     *\n     * Negative\n     * - Freeze all the items with max violations.\n     */\n    hasNonFrozenItems = false;\n    flexItems.forEach(item => {\n      if (totalViolation === 0 || Math.sign(totalViolation) === Math.sign(item.violation)) {\n        item.frozen = true;\n      } else if (!item.frozen) {\n        hasNonFrozenItems = true;\n      }\n    });\n  }\n\n  return cascadeRounding(flexItems);\n}\n\nfunction cascadeRounding(flexItems): number[] {\n  /*\n  Given an array of floats that sum to an integer, this rounds the floats\n  and returns an array of integers with the same sum.\n  */\n\n  let fpTotal = 0;\n  let intTotal = 0;\n  let roundedArray = [];\n  flexItems.forEach(function (item) {\n    let float = item.targetMainSize;\n    let integer = Math.round(float + fpTotal) - intTotal;\n    fpTotal += float;\n    intTotal += integer;\n    roundedArray.push(integer);\n  });\n\n  return roundedArray;\n}\n"],"names":[],"version":3,"file":"TableUtils.module.js.map"}