cdk-common 0.0.67 → 2.0.2

package/node_modules/table/dist/src/getBorderCharacters.d.ts

@@ -0,0 +1,2 @@
+import type { BorderConfig } from './types/api';
+export declare const getBorderCharacters: (name: string) => BorderConfig;

package/node_modules/table/dist/src/getBorderCharacters.js

@@ -0,0 +1,89 @@
+"use strict";
+/* eslint-disable sort-keys-fix/sort-keys-fix */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBorderCharacters = void 0;
+const getBorderCharacters = (name) => {
+    if (name === 'honeywell') {
+        return {
+            topBody: '═',
+            topJoin: '╤',
+            topLeft: '╔',
+            topRight: '╗',
+            bottomBody: '═',
+            bottomJoin: '╧',
+            bottomLeft: '╚',
+            bottomRight: '╝',
+            bodyLeft: '║',
+            bodyRight: '║',
+            bodyJoin: '│',
+            headerJoin: '┬',
+            joinBody: '─',
+            joinLeft: '╟',
+            joinRight: '╢',
+            joinJoin: '┼',
+        };
+    }
+    if (name === 'norc') {
+        return {
+            topBody: '─',
+            topJoin: '┬',
+            topLeft: '┌',
+            topRight: '┐',
+            bottomBody: '─',
+            bottomJoin: '┴',
+            bottomLeft: '└',
+            bottomRight: '┘',
+            bodyLeft: '│',
+            bodyRight: '│',
+            bodyJoin: '│',
+            headerJoin: '┬',
+            joinBody: '─',
+            joinLeft: '├',
+            joinRight: '┤',
+            joinJoin: '┼',
+        };
+    }
+    if (name === 'ramac') {
+        return {
+            topBody: '-',
+            topJoin: '+',
+            topLeft: '+',
+            topRight: '+',
+            bottomBody: '-',
+            bottomJoin: '+',
+            bottomLeft: '+',
+            bottomRight: '+',
+            bodyLeft: '|',
+            bodyRight: '|',
+            bodyJoin: '|',
+            headerJoin: '+',
+            joinBody: '-',
+            joinLeft: '|',
+            joinRight: '|',
+            joinJoin: '|',
+        };
+    }
+    if (name === 'void') {
+        return {
+            topBody: '',
+            topJoin: '',
+            topLeft: '',
+            topRight: '',
+            bottomBody: '',
+            bottomJoin: '',
+            bottomLeft: '',
+            bottomRight: '',
+            bodyLeft: '',
+            bodyRight: '',
+            bodyJoin: '',
+            headerJoin: '',
+            joinBody: '',
+            joinLeft: '',
+            joinRight: '',
+            joinJoin: '',
+        };
+    }
+    throw new Error('Unknown border template "' + name + '".');
+};
+exports.getBorderCharacters = getBorderCharacters;
+//# sourceMappingURL=getBorderCharacters.js.map

package/node_modules/table/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+import { createStream } from './createStream';
+import { getBorderCharacters } from './getBorderCharacters';
+import { table } from './table';
+export { table, createStream, getBorderCharacters, };
+export * from './types/api';

package/node_modules/table/dist/src/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.getBorderCharacters = exports.createStream = exports.table = void 0;
+const createStream_1 = require("./createStream");
+Object.defineProperty(exports, "createStream", { enumerable: true, get: function () { return createStream_1.createStream; } });
+const getBorderCharacters_1 = require("./getBorderCharacters");
+Object.defineProperty(exports, "getBorderCharacters", { enumerable: true, get: function () { return getBorderCharacters_1.getBorderCharacters; } });
+const table_1 = require("./table");
+Object.defineProperty(exports, "table", { enumerable: true, get: function () { return table_1.table; } });
+__exportStar(require("./types/api"), exports);
+//# sourceMappingURL=index.js.map

package/node_modules/table/dist/src/makeStreamConfig.d.ts

@@ -0,0 +1,7 @@
+import type { StreamUserConfig } from './types/api';
+import type { StreamConfig } from './types/internal';
+/**
+ * Makes a new configuration object out of the userConfig object
+ * using default values for the missing configuration properties.
+ */
+export declare const makeStreamConfig: (config: StreamUserConfig) => StreamConfig;

package/node_modules/table/dist/src/makeStreamConfig.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStreamConfig = void 0;
+const utils_1 = require("./utils");
+const validateConfig_1 = require("./validateConfig");
+/**
+ * Creates a configuration for every column using default
+ * values for the missing configuration properties.
+ */
+const makeColumnsConfig = (columnCount, columns = {}, columnDefault) => {
+    return Array.from({ length: columnCount }).map((_, index) => {
+        return {
+            alignment: 'left',
+            paddingLeft: 1,
+            paddingRight: 1,
+            truncate: Number.POSITIVE_INFINITY,
+            verticalAlignment: 'top',
+            wrapWord: false,
+            ...columnDefault,
+            ...columns[index],
+        };
+    });
+};
+/**
+ * Makes a new configuration object out of the userConfig object
+ * using default values for the missing configuration properties.
+ */
+const makeStreamConfig = (config) => {
+    (0, validateConfig_1.validateConfig)('streamConfig.json', config);
+    if (config.columnDefault.width === undefined) {
+        throw new Error('Must provide config.columnDefault.width when creating a stream.');
+    }
+    return {
+        drawVerticalLine: () => {
+            return true;
+        },
+        ...config,
+        border: (0, utils_1.makeBorderConfig)(config.border),
+        columns: makeColumnsConfig(config.columnCount, config.columns, config.columnDefault),
+    };
+};
+exports.makeStreamConfig = makeStreamConfig;
+//# sourceMappingURL=makeStreamConfig.js.map

package/node_modules/table/dist/src/makeTableConfig.d.ts

@@ -0,0 +1,7 @@
+import type { TableUserConfig } from './types/api';
+import type { Row, TableConfig } from './types/internal';
+/**
+ * Makes a new configuration object out of the userConfig object
+ * using default values for the missing configuration properties.
+ */
+export declare const makeTableConfig: (rows: Row[], config?: TableUserConfig) => TableConfig;

package/node_modules/table/dist/src/makeTableConfig.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTableConfig = void 0;
+const calculateColumnWidths_1 = __importDefault(require("./calculateColumnWidths"));
+const utils_1 = require("./utils");
+const validateConfig_1 = require("./validateConfig");
+/**
+ * Creates a configuration for every column using default
+ * values for the missing configuration properties.
+ */
+const makeColumnsConfig = (rows, columns, columnDefault) => {
+    const columnWidths = (0, calculateColumnWidths_1.default)(rows);
+    return rows[0].map((_, columnIndex) => {
+        return {
+            alignment: 'left',
+            paddingLeft: 1,
+            paddingRight: 1,
+            truncate: Number.POSITIVE_INFINITY,
+            verticalAlignment: 'top',
+            width: columnWidths[columnIndex],
+            wrapWord: false,
+            ...columnDefault,
+            ...columns === null || columns === void 0 ? void 0 : columns[columnIndex],
+        };
+    });
+};
+const makeHeaderConfig = (config) => {
+    if (!config.header) {
+        return undefined;
+    }
+    return {
+        alignment: 'center',
+        paddingLeft: 1,
+        paddingRight: 1,
+        truncate: Number.POSITIVE_INFINITY,
+        wrapWord: false,
+        ...config.header,
+    };
+};
+/**
+ * Makes a new configuration object out of the userConfig object
+ * using default values for the missing configuration properties.
+ */
+const makeTableConfig = (rows, config = {}) => {
+    var _a, _b, _c;
+    (0, validateConfig_1.validateConfig)('config.json', config);
+    return {
+        ...config,
+        border: (0, utils_1.makeBorderConfig)(config.border),
+        columns: makeColumnsConfig(rows, config.columns, config.columnDefault),
+        drawHorizontalLine: (_a = config.drawHorizontalLine) !== null && _a !== void 0 ? _a : (() => {
+            return true;
+        }),
+        drawVerticalLine: (_b = config.drawVerticalLine) !== null && _b !== void 0 ? _b : (() => {
+            return true;
+        }),
+        header: makeHeaderConfig(config),
+        singleLine: (_c = config.singleLine) !== null && _c !== void 0 ? _c : false,
+    };
+};
+exports.makeTableConfig = makeTableConfig;
+//# sourceMappingURL=makeTableConfig.js.map

package/node_modules/table/dist/src/mapDataUsingRowHeights.d.ts

@@ -0,0 +1,2 @@
+import type { BaseConfig, Row } from './types/internal';
+export declare const mapDataUsingRowHeights: (unmappedRows: Row[], rowHeights: number[], config: BaseConfig) => Row[];

package/node_modules/table/dist/src/mapDataUsingRowHeights.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapDataUsingRowHeights = void 0;
+const wrapCell_1 = require("./wrapCell");
+const createEmptyStrings = (length) => {
+    return new Array(length).fill('');
+};
+const padCellVertically = (lines, rowHeight, columnConfig) => {
+    const { verticalAlignment } = columnConfig;
+    const availableLines = rowHeight - lines.length;
+    if (verticalAlignment === 'top') {
+        return [...lines, ...createEmptyStrings(availableLines)];
+    }
+    if (verticalAlignment === 'bottom') {
+        return [...createEmptyStrings(availableLines), ...lines];
+    }
+    return [
+        ...createEmptyStrings(Math.floor(availableLines / 2)),
+        ...lines,
+        ...createEmptyStrings(Math.ceil(availableLines / 2)),
+    ];
+};
+const flatten = (array) => {
+    return [].concat(...array);
+};
+const mapDataUsingRowHeights = (unmappedRows, rowHeights, config) => {
+    const tableWidth = unmappedRows[0].length;
+    const mappedRows = unmappedRows.map((unmappedRow, unmappedRowIndex) => {
+        const outputRowHeight = rowHeights[unmappedRowIndex];
+        const outputRow = Array.from({ length: outputRowHeight }, () => {
+            return new Array(tableWidth).fill('');
+        });
+        unmappedRow.forEach((cell, cellIndex) => {
+            const cellLines = (0, wrapCell_1.wrapCell)(cell, config.columns[cellIndex].width, config.columns[cellIndex].wrapWord);
+            const paddedCellLines = padCellVertically(cellLines, outputRowHeight, config.columns[cellIndex]);
+            paddedCellLines.forEach((cellLine, cellLineIndex) => {
+                outputRow[cellLineIndex][cellIndex] = cellLine;
+            });
+        });
+        return outputRow;
+    });
+    return flatten(mappedRows);
+};
+exports.mapDataUsingRowHeights = mapDataUsingRowHeights;
+//# sourceMappingURL=mapDataUsingRowHeights.js.map

package/node_modules/table/dist/src/padTableData.d.ts

@@ -0,0 +1,3 @@
+import type { BaseConfig, Row } from './types/internal';
+export declare const padString: (input: string, paddingLeft: number, paddingRight: number) => string;
+export declare const padTableData: (rows: Row[], config: BaseConfig) => Row[];

package/node_modules/table/dist/src/padTableData.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.padTableData = exports.padString = void 0;
+const padString = (input, paddingLeft, paddingRight) => {
+    return ' '.repeat(paddingLeft) + input + ' '.repeat(paddingRight);
+};
+exports.padString = padString;
+const padTableData = (rows, config) => {
+    return rows.map((cells) => {
+        return cells.map((cell, cellIndex) => {
+            const { paddingLeft, paddingRight } = config.columns[cellIndex];
+            return (0, exports.padString)(cell, paddingLeft, paddingRight);
+        });
+    });
+};
+exports.padTableData = padTableData;
+//# sourceMappingURL=padTableData.js.map

package/node_modules/table/dist/src/stringifyTableData.d.ts

@@ -0,0 +1,2 @@
+import type { Row } from './types/internal';
+export declare const stringifyTableData: (rows: unknown[][]) => Row[];

package/node_modules/table/dist/src/stringifyTableData.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyTableData = void 0;
+const utils_1 = require("./utils");
+const stringifyTableData = (rows) => {
+    return rows.map((cells) => {
+        return cells.map((cell) => {
+            return (0, utils_1.normalizeString)(String(cell));
+        });
+    });
+};
+exports.stringifyTableData = stringifyTableData;
+//# sourceMappingURL=stringifyTableData.js.map

package/node_modules/table/dist/src/table.d.ts

@@ -0,0 +1,2 @@
+import type { TableUserConfig } from './types/api';
+export declare const table: (data: unknown[][], userConfig?: TableUserConfig) => string;

package/node_modules/table/dist/src/table.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.table = void 0;
+const alignTableData_1 = require("./alignTableData");
+const calculateCellWidths_1 = require("./calculateCellWidths");
+const calculateRowHeights_1 = require("./calculateRowHeights");
+const drawTable_1 = require("./drawTable");
+const makeTableConfig_1 = require("./makeTableConfig");
+const mapDataUsingRowHeights_1 = require("./mapDataUsingRowHeights");
+const padTableData_1 = require("./padTableData");
+const stringifyTableData_1 = require("./stringifyTableData");
+const truncateTableData_1 = require("./truncateTableData");
+const validateTableData_1 = require("./validateTableData");
+const table = (data, userConfig = {}) => {
+    (0, validateTableData_1.validateTableData)(data);
+    let rows = (0, stringifyTableData_1.stringifyTableData)(data);
+    const config = (0, makeTableConfig_1.makeTableConfig)(rows, userConfig);
+    rows = (0, truncateTableData_1.truncateTableData)(rows, config);
+    const rowHeights = (0, calculateRowHeights_1.calculateRowHeights)(rows, config);
+    rows = (0, mapDataUsingRowHeights_1.mapDataUsingRowHeights)(rows, rowHeights, config);
+    rows = (0, alignTableData_1.alignTableData)(rows, config);
+    rows = (0, padTableData_1.padTableData)(rows, config);
+    const cellWidths = (0, calculateCellWidths_1.calculateCellWidths)(rows[0]);
+    return (0, drawTable_1.drawTable)(rows, cellWidths, rowHeights, config);
+};
+exports.table = table;
+//# sourceMappingURL=table.js.map

package/node_modules/table/dist/src/truncateTableData.d.ts

@@ -0,0 +1,6 @@
+import type { BaseConfig, Row } from './types/internal';
+export declare const truncateString: (input: string, length: number) => string;
+/**
+ * @todo Make it work with ASCII content.
+ */
+export declare const truncateTableData: (rows: Row[], config: BaseConfig) => Row[];

package/node_modules/table/dist/src/truncateTableData.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateTableData = exports.truncateString = void 0;
+const lodash_truncate_1 = __importDefault(require("lodash.truncate"));
+const truncateString = (input, length) => {
+    return (0, lodash_truncate_1.default)(input, { length,
+        omission: '…' });
+};
+exports.truncateString = truncateString;
+/**
+ * @todo Make it work with ASCII content.
+ */
+const truncateTableData = (rows, config) => {
+    return rows.map((cells) => {
+        return cells.map((cell, cellIndex) => {
+            return (0, exports.truncateString)(cell, config.columns[cellIndex].truncate);
+        });
+    });
+};
+exports.truncateTableData = truncateTableData;
+//# sourceMappingURL=truncateTableData.js.map

package/node_modules/table/dist/src/types/api.d.ts

@@ -0,0 +1,114 @@
+export declare type DrawLinePredicate = (index: number, size: number) => boolean;
+export declare type DrawVerticalLine = DrawLinePredicate;
+export declare type DrawHorizontalLine = DrawLinePredicate;
+export declare type BorderUserConfig = {
+    readonly topLeft?: string;
+    readonly topRight?: string;
+    readonly topBody?: string;
+    readonly topJoin?: string;
+    readonly bottomLeft?: string;
+    readonly bottomRight?: string;
+    readonly bottomBody?: string;
+    readonly bottomJoin?: string;
+    readonly joinLeft?: string;
+    readonly joinRight?: string;
+    readonly joinBody?: string;
+    readonly joinJoin?: string;
+    readonly headerJoin?: string;
+    readonly bodyRight?: string;
+    readonly bodyLeft?: string;
+    readonly bodyJoin?: string;
+};
+export declare type BorderConfig = Required<BorderUserConfig>;
+export declare type Alignment = 'center' | 'justify' | 'left' | 'right';
+export declare type VerticalAlignment = 'bottom' | 'middle' | 'top';
+export declare type ColumnUserConfig = {
+    /**
+     * Cell content horizontal alignment (default: left)
+     */
+    readonly alignment?: Alignment;
+    /**
+     * Cell content vertical alignment (default: top)
+     */
+    readonly verticalAlignment?: VerticalAlignment;
+    /**
+     * Column width (default: auto calculation based on the cell content)
+     */
+    readonly width?: number;
+    /**
+     * Number of characters are which the content will be truncated (default: Infinity)
+     */
+    readonly truncate?: number;
+    /**
+     * Cell content padding width left (default: 1)
+     */
+    readonly paddingLeft?: number;
+    /**
+     * Cell content padding width right (default: 1)
+     */
+    readonly paddingRight?: number;
+    /**
+     * If true, the text is broken at the nearest space or one of the special characters: "\|/_.,;-"
+     */
+    readonly wrapWord?: boolean;
+};
+export declare type HeaderUserConfig = Omit<ColumnUserConfig, 'verticalAlignment' | 'width'> & {
+    readonly content: string;
+};
+export declare type BaseUserConfig = {
+    /**
+     * Custom border
+     */
+    readonly border?: BorderUserConfig;
+    /**
+     * Default values for all columns. Column specific settings overwrite the default values.
+     */
+    readonly columnDefault?: ColumnUserConfig;
+    /**
+     * Column specific configuration.
+     */
+    readonly columns?: Indexable<ColumnUserConfig>;
+    /**
+     * Used to tell whether to draw a vertical line.
+     * This callback is called for each non-content line of the table.
+     * The default behavior is to always return true.
+     */
+    readonly drawVerticalLine?: DrawVerticalLine;
+};
+export declare type TableUserConfig = BaseUserConfig & {
+    /**
+     * The header configuration
+     */
+    readonly header?: HeaderUserConfig;
+    /**
+     * Used to tell whether to draw a horizontal line.
+     * This callback is called for each non-content line of the table.
+     * The default behavior is to always return true.
+     */
+    readonly drawHorizontalLine?: DrawHorizontalLine;
+    /**
+     * Horizontal lines inside the table are not drawn.
+     */
+    readonly singleLine?: boolean;
+};
+export declare type StreamUserConfig = BaseUserConfig & {
+    /**
+     * The number of columns
+     */
+    readonly columnCount: number;
+    /**
+     * Default values for all columns. Column specific settings overwrite the default values.
+     */
+    readonly columnDefault: ColumnUserConfig & {
+        /**
+         * The default width for each column
+         */
+        readonly width: number;
+    };
+};
+export declare type WritableStream = {
+    readonly write: (rows: string[]) => void;
+};
+export declare type Indexable<T> = {
+    readonly [index: number]: T;
+};

package/node_modules/table/dist/src/types/api.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=api.js.map

package/node_modules/table/dist/src/types/internal.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/table/dist/src/types/internal.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=internal.js.map

package/node_modules/table/dist/src/utils.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/table/dist/src/utils.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distributeUnevenly = exports.countSpaceSequence = exports.groupBySizes = exports.makeBorderConfig = exports.splitAnsi = exports.normalizeString = void 0;
+const slice_ansi_1 = __importDefault(require("slice-ansi"));
+const string_width_1 = __importDefault(require("string-width"));
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const getBorderCharacters_1 = require("./getBorderCharacters");
+/**
+ * Converts Windows-style newline to Unix-style
+ *
+ * @internal
+ */
+const normalizeString = (input) => {
+    return input.replace(/\r\n/g, '\n');
+};
+exports.normalizeString = normalizeString;
+/**
+ * Splits ansi string by newlines
+ *
+ * @internal
+ */
+const splitAnsi = (input) => {
+    const lengths = (0, strip_ansi_1.default)(input).split('\n').map(string_width_1.default);
+    const result = [];
+    let startIndex = 0;
+    lengths.forEach((length) => {
+        result.push(length === 0 ? '' : (0, slice_ansi_1.default)(input, startIndex, startIndex + length));
+        // Plus 1 for the newline character itself
+        startIndex += length + 1;
+    });
+    return result;
+};
+exports.splitAnsi = splitAnsi;
+/**
+ * Merges user provided border characters with the default border ("honeywell") characters.
+ *
+ * @internal
+ */
+const makeBorderConfig = (border) => {
+    return {
+        ...(0, getBorderCharacters_1.getBorderCharacters)('honeywell'),
+        ...border,
+    };
+};
+exports.makeBorderConfig = makeBorderConfig;
+/**
+ * Groups the array into sub-arrays by sizes.
+ *
+ * @internal
+ * @example
+ * groupBySizes(['a', 'b', 'c', 'd', 'e'], [2, 1, 2]) = [ ['a', 'b'], ['c'], ['d', 'e'] ]
+ */
+const groupBySizes = (array, sizes) => {
+    let startIndex = 0;
+    return sizes.map((size) => {
+        const group = array.slice(startIndex, startIndex + size);
+        startIndex += size;
+        return group;
+    });
+};
+exports.groupBySizes = groupBySizes;
+/**
+ * Counts the number of continuous spaces in a string
+ *
+ * @internal
+ * @example
+ * countGroupSpaces('a  bc  de f') = 3
+ */
+const countSpaceSequence = (input) => {
+    var _a, _b;
+    return (_b = (_a = input.match(/\s+/g)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+};
+exports.countSpaceSequence = countSpaceSequence;
+/**
+ * Creates the non-increasing number array given sum and length
+ * whose the difference between maximum and minimum is not greater than 1
+ *
+ * @internal
+ * @example
+ * distributeUnevenly(6, 3) = [2, 2, 2]
+ * distributeUnevenly(8, 3) = [3, 3, 2]
+ */
+const distributeUnevenly = (sum, length) => {
+    const result = Array.from({ length }).fill(Math.floor(sum / length));
+    return result.map((element, index) => {
+        return element + (index < sum % length ? 1 : 0);
+    });
+};
+exports.distributeUnevenly = distributeUnevenly;
+//# sourceMappingURL=utils.js.map

package/node_modules/table/dist/src/validateConfig.d.ts

@@ -0,0 +1,2 @@
+import type { TableUserConfig } from './types/api';
+export declare const validateConfig: (schemaId: 'config.json' | 'streamConfig.json', config: TableUserConfig) => void;

package/node_modules/table/dist/src/validateConfig.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = void 0;
+const validators_1 = __importDefault(require("./generated/validators"));
+const validateConfig = (schemaId, config) => {
+    const validate = validators_1.default[schemaId];
+    if (!validate(config) && validate.errors) {
+        // eslint-disable-next-line promise/prefer-await-to-callbacks
+        const errors = validate.errors.map((error) => {
+            return {
+                message: error.message,
+                params: error.params,
+                schemaPath: error.schemaPath,
+            };
+        });
+        /* eslint-disable no-console */
+        console.log('config', config);
+        console.log('errors', errors);
+        /* eslint-enable no-console */
+        throw new Error('Invalid config.');
+    }
+};
+exports.validateConfig = validateConfig;
+//# sourceMappingURL=validateConfig.js.map

package/node_modules/table/dist/src/validateTableData.d.ts

@@ -0,0 +1 @@
+export declare const validateTableData: (rows: unknown[][]) => void;