@parliamentarch/core 4.0.0

package/README.md

@@ -0,0 +1,99 @@
+# Parliamentarch-TS Core
+
+Tools to generate arch-styled parliamentary diagrams.
+
+![Example diagram](../../sample.svg)
+
+This package handles two things: majorly (in the `geometry` submodule), the geometry of how the seats are arranged in space, and as an aside (in the `utils` submodule), some util functions shared by the other modules taking over from there.
+
+Those won't be enough to generate SVG files or nodes by themselves. In fact, there is nothing specific to SVG in this package, and a wholly different display system could be used to generate a diagram from what this package provides.
+
+## Base math and layout
+
+The idea is to display a certain number of seats so that they collectively form a hemicycle, which is a half-annulus where the inner radius is also a half of the outer radius. The shape fits in a 2:1 rectangle in a landscape orientation, with the hole of the annulus at the bottom.
+
+The seats are placed in rows, such that:
+
+- The rows are semi-circles, concentric to the annulus.
+- The difference between the radii of two consecutive rows is a constant called the "row thickness" (radii is the plural of radius).
+- The seats are circles (or disks) of equal diameter. That radius divided by the row thickness is called the "seat radius factor".
+- The center of a seat is on the semi-circle the seat's row.
+- Within each row, the distance between the centers of two consecutive seats is a constant, at least equal to the row thickness.
+- The innermost row's semi-circle is the inner arc of the annulus.
+- The radius of the outermost row's semi-circle is equal to the radius of the outer arc minus half of the row thickness, such that no seat may overlap the outer arc.
+- The vertical distance between the center of the bottom-most seats of each row, which are the first and last seat of each row, is equal to half of the row thickness, such that no seat may overlap the bottom of the rectangle.
+- However, when a row contains only one seat, the previous rule does not apply, and the seat is placed at the horizontal center of the diagram.
+
+As a result of these constraints, there is a maximum number of seats that can be placed in a diagram with a given number of rows. For numbers of seats below this maximum, there exists a number of strategies to distribute the seats among the rows.
+
+It is also possible to change the span angle of the diagram (which is 180° in the example above). If a smaller angle is specified, the initial annulus must be cut along two radii of the larger circle. For seat placements, what applied to the bottom of the rectangle now applies to the two radii.
+
+## Tweakable parameters
+
+As hinted above, some parameters can be set to customize the layout of the diagram:
+
+- The span angle of the hemicycle can be sety to a value lower than 180° (higher values are not supported). However, values so low as to prevent some rows from containing even one seat are not supported, will yield incorrect results, and may throw errors in future versions.
+- The number of rows can be set higher than the minimum required to hold the provided number of seats. This will result in smaller seats (more precisely, a smaller row thickness).
+- The seat radius factor can be set between 0 and 1, with the seats touching their neighbors when the factor is 1.
+- As long as the number of seats is not the maximum number of seats for the given number of rows, different strategies can be chosen to distribute the seats.
+
+## Geometry module contents
+
+These are found in the `@parliamentarch/core/geometry` module.
+
+`getNRowsFromNSeats(nSeats: number, spanAngle?: number): number`
+
+Returns the minimum number of rows required to hold the given number of seats in a diagram with the given span angle.
+
+`getRowsFromNRows(nRows: number, spanAngle?: number): number[]`
+
+Returns a list of each row's maximum seat capacity, starting from inner to outer, from a given number of rows and span angle. The list is increasing and its length is equal to the number of rows.
+
+`getRowThickness(nRows: number): number`
+
+Returns the row thickness, i.e the difference between the radii of two consecutive rows, for a given number of rows.
+
+`FillingStrategy`
+
+A string enum of the implemented strategies to fill the seats among the rows:
+
+- `DEFAULT`: The seats are distributed proportionally to the maximal number of seats each row can hold. The result is that the lateral distance between the seats is close among all rows.
+- `EMPTY_INNER`: This selects as few outermost rows as necessary to hold the given seats, then distributes the seats proportionally among them. Depending on the number of seats and rows, this either leaves empty inner rows, or is equivalent to the `DEFAULT` strategy. This is equivalent to the legacy "dense rows" option, in that in non-empty rows, the distance between consecutive seats is the smallest possible, and is close among all rows.
+- `OUTER_PRIORITY`: This fills the rows to their maximal capacity, starting with the outermost rows going in. The result is that given a number of rows, adding one seat makes a change in only one row.
+
+`getSeatCenters(nSeats: number, options?): Map<[number, number], number>`
+
+This is the main function of the submodule. The options are as follows:
+
+- `minNRows?: number`: Sets a minimum number of rows.
+- `fillingStrategy?: FillingStrategy`: The strategy to use, defaults to `DEFAULT`.
+- `spanAngle?: number`: The span angle of the diagram in degrees, defaults to 180.
+
+The function returns a map representing the ensemble of seats. The keys are `[x, y]` pairs, the cartesian coordinates of the center of the seat. The coordinates start from the bottom-left corner of the rectangle, with the x axis pointing to the right and the y axis pointing up. The outer radius of the annulus, equal to the height and to half of the width of the rectangle, is 1, so `x` goes from 0 to 2 and `y` goes from 0 to 1.
+
+The values are the angle, in radians, calculated from the right-outermost point of the annulus arc, through the center of the annulus, to the center of the seat. Sorting the keys by decreasing value returns the seats arranged from left to right. The order of the entries in the Map is meaningless.
+
+## Utils module contents
+
+These are found in the `@parliamentarch/core/utils` module.
+
+`dispatchSeats<SeatDisplay, SeatLocation>(attribution, seats): Map<SeatDisplay, SeatLocation[]>`
+
+This generic function merges an attribution of seat informations with a list of seat locations, to a more useful format.
+
+- `attribution: ReadonlyMap<SeatDisplay, number> | readonly WithNumber<SeatDisplay>[]` (WithNumber meaning that it takes an optional `nSeats` number parameter, defaulting to 1): SeatDisplay usually represents a team owning seats, and this parameter represents how many seats each team has.
+- `seats: Iterable<SeatLocation>`: the location of seats. These must be in the same number as the sum of seats for all teams, otherwise an error will be thrown.
+
+`regroupSeatCenters<SeatDisplay, SeatLocation=(readonly [number, number])>(seatCenters): Iterable<readonly [SeatDisplay, readonly SeatLocation[]]>`
+
+This generic function turns one representation of how each seat is displayed, into a more versatile one.
+
+- `seatCenters: Iterable<readonly [SeatLocation, SeatDisplay]>`: a simple, naive mapping of each seat location to how it should be displayed
+
+`precomputeFromAttribution<SeatDisplay>(attribution, options?): PrecomputeReturn<SeatDisplay>`
+
+This function pre-calculates some information from an attribution of seats, making it almost enough to be displayed. The return value is an object containing grouped seat centers as returned by the previous function, under the key `groupedSeatCenters`, and the radius of the seats in the same unit as the coordinates, under the key `seatActualRadius`.
+
+- `attribution: ReadonlyMap<SeatDisplay, number> | readonly WithNumber<SeatDisplay>[]`
+- `options.seatRadiusFactor`: the factor between 0 and 1 described earlier. At 1, neighboring seats will touch one another.
+- `options`: the rest of the options are the same as taken by the `getSeatCenters` function.

package/dist/geometry.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Returns the thickness of a row in the same unit as the coordinates.
+ * It is equal to the diameter of a single seat.
+ *
+ * If you divide the half-disk of the hemicycle into one half-disk of half the radius and one half-annulus outside of it,
+ * the innermost row lies on the border between the two, and the outermost row lies entirely inside the half-annulus.
+ * So, looking at the line cutting the circle and the annulus in half (which is the bottom border of the diagram),
+ * all rows minus one half of the innermost are on the left, same on the right,
+ * and the radius of the void at the center is equal to that value again.
+ * So, total = 4 * (nRows-.5) = 4 * nRows - 2.
+ */
+export declare function getRowThickness(nRows: number): number;
+/**
+ * This indicates the maximal number of seats for each row for a given number of rows.
+ * @param spanAngle if provided, it is the angle in degrees that the hemicycle, as an annulus arc, covers.
+ * @returns an array of number of seats per row, from inner to outer.
+ * The length of the array is nRows.
+ */
+export declare function getRowsFromNRows(nRows: number, spanAngle?: number): number[];
+/**
+ * Returns the minimal number of rows necessary to contain nSeats seats.
+ */
+export declare function getNRowsFromNSeats(nSeats: number, spanAngle?: number): number;
+export declare enum FillingStrategy {
+    /**
+     * The seats are distributed among all the rows,
+     * proportionally to the maximal number of seats each row can contain.
+     */
+    DEFAULT = "default",
+    /**
+     * Selects as few outermost rows as necessary, then distributes the seats among them,
+     * proportionally to the maximal number of seats each row can contain.
+     */
+    EMPTY_INNER = "empty_inner",
+    /**
+     * Fills up the rows as much as possible, starting from the outermost ones.
+     */
+    OUTER_PRIORITY = "outer_priority"
+}
+export interface GetSeatCentersOptions {
+    minNRows: number;
+    fillingStrategy: FillingStrategy;
+    spanAngle: number;
+}
+/**
+ * Computes the coordinates of the centers of the seats, with (as a bonus) the angle of each seat in the hemicycle.
+ * The canvas is assumed to be 2 in width and 1 in height, with the x axis pointing right and the y axis pointing up.
+ * The angle is calculated from the [1, 0] center of the hemicycle, in radians and in trigonometric positive direction,
+ * tending to 0 for the rightmost seats, 90° or PI/2 for the center, and 180° or PI for the leftmost seats.
+ * @param minNRows The minimal number of rows required to contain `nSeats` seats will be computed automatically.
+ * If `minNRows` is greater, then that will be the number of rows, otherwise the parameter is ignored.
+ * Passing a higher number of rows will make the diagram sparser,
+ * for which non-default filling strategies are more adapted.
+ * @param fillingStrategy determines how the seats are distributed among the rows, see the `FillingStrategy` enum.
+ * @param spanAngle is the angle from the side of the rightmost seats,
+ * through the center, to the side of the leftmost seats.
+ * It takes a value in degrees and defaults to 180 to make a true hemicycle.
+ * Values above 180 are not supported.
+ * @returns a map whose keys are the seat centers as [x, y] coordinates, with the angle of the seat as values.
+ */
+export declare function getSeatCenters(nSeats: number, { minNRows, fillingStrategy, spanAngle, }?: Partial<GetSeatCentersOptions>): Map<[number, number], number>;

package/dist/geometry.js

@@ -0,0 +1,162 @@
+// default angle, in degrees, coming from the rightmost seats through the center to the leftmost seats
+const DEFAULT_SPAN_ANGLE = 180;
+/**
+ * Returns the thickness of a row in the same unit as the coordinates.
+ * It is equal to the diameter of a single seat.
+ *
+ * If you divide the half-disk of the hemicycle into one half-disk of half the radius and one half-annulus outside of it,
+ * the innermost row lies on the border between the two, and the outermost row lies entirely inside the half-annulus.
+ * So, looking at the line cutting the circle and the annulus in half (which is the bottom border of the diagram),
+ * all rows minus one half of the innermost are on the left, same on the right,
+ * and the radius of the void at the center is equal to that value again.
+ * So, total = 4 * (nRows-.5) = 4 * nRows - 2.
+ */
+export function getRowThickness(nRows) {
+    return 1 / (4 * nRows - 2);
+}
+/**
+ * This indicates the maximal number of seats for each row for a given number of rows.
+ * @param spanAngle if provided, it is the angle in degrees that the hemicycle, as an annulus arc, covers.
+ * @returns an array of number of seats per row, from inner to outer.
+ * The length of the array is nRows.
+ */
+export function getRowsFromNRows(nRows, spanAngle = DEFAULT_SPAN_ANGLE) {
+    const rad = getRowThickness(nRows);
+    const radianSpanAngle = Math.PI * spanAngle / 180;
+    return Array.from({ length: nRows }, (_, r) => {
+        const rowArcRadius = .5 + 2 * r * rad;
+        return Math.floor(radianSpanAngle * rowArcRadius / (2 * rad));
+    });
+}
+/**
+ * Returns the minimal number of rows necessary to contain nSeats seats.
+ */
+export function getNRowsFromNSeats(nSeats, spanAngle = DEFAULT_SPAN_ANGLE) {
+    let nRows = 1;
+    while (getRowsFromNRows(nRows, spanAngle).reduce((a, b) => a + b, 0) < nSeats) {
+        nRows++;
+    }
+    return nRows;
+}
+export var FillingStrategy;
+(function (FillingStrategy) {
+    /**
+     * The seats are distributed among all the rows,
+     * proportionally to the maximal number of seats each row can contain.
+     */
+    FillingStrategy["DEFAULT"] = "default";
+    /**
+     * Selects as few outermost rows as necessary, then distributes the seats among them,
+     * proportionally to the maximal number of seats each row can contain.
+     */
+    FillingStrategy["EMPTY_INNER"] = "empty_inner";
+    /**
+     * Fills up the rows as much as possible, starting from the outermost ones.
+     */
+    FillingStrategy["OUTER_PRIORITY"] = "outer_priority";
+})(FillingStrategy || (FillingStrategy = {}));
+/**
+ * Computes the coordinates of the centers of the seats, with (as a bonus) the angle of each seat in the hemicycle.
+ * The canvas is assumed to be 2 in width and 1 in height, with the x axis pointing right and the y axis pointing up.
+ * The angle is calculated from the [1, 0] center of the hemicycle, in radians and in trigonometric positive direction,
+ * tending to 0 for the rightmost seats, 90° or PI/2 for the center, and 180° or PI for the leftmost seats.
+ * @param minNRows The minimal number of rows required to contain `nSeats` seats will be computed automatically.
+ * If `minNRows` is greater, then that will be the number of rows, otherwise the parameter is ignored.
+ * Passing a higher number of rows will make the diagram sparser,
+ * for which non-default filling strategies are more adapted.
+ * @param fillingStrategy determines how the seats are distributed among the rows, see the `FillingStrategy` enum.
+ * @param spanAngle is the angle from the side of the rightmost seats,
+ * through the center, to the side of the leftmost seats.
+ * It takes a value in degrees and defaults to 180 to make a true hemicycle.
+ * Values above 180 are not supported.
+ * @returns a map whose keys are the seat centers as [x, y] coordinates, with the angle of the seat as values.
+ */
+export function getSeatCenters(nSeats, { minNRows = 0, fillingStrategy = FillingStrategy.DEFAULT, spanAngle = DEFAULT_SPAN_ANGLE, } = {}) {
+    const nRows = Math.max(minNRows, getNRowsFromNSeats(nSeats, spanAngle));
+    const rowThicc = getRowThickness(nRows);
+    const spanAngleMargin = (1 - spanAngle / 180) * Math.PI / 2;
+    const maxedRows = getRowsFromNRows(nRows, spanAngle);
+    let startingRow, fillingRatio, seatsOnStartingRow;
+    switch (fillingStrategy) {
+        case FillingStrategy.DEFAULT:
+            startingRow = 0;
+            fillingRatio = nSeats / maxedRows.reduce((a, b) => a + b, 0);
+            break;
+        case FillingStrategy.EMPTY_INNER:
+            {
+                const rows = maxedRows.slice();
+                while (rows.slice(1).reduce((a, b) => a + b, 0) >= nSeats) {
+                    rows.shift();
+                }
+                // here, rows represents the rows which are enough to contain nSeats,
+                // and their number of seats.
+                // this row will be the first one to contain seats
+                // the innermost ones are empty
+                startingRow = nRows - rows.length;
+                fillingRatio = nSeats / rows.reduce((a, b) => a + b, 0);
+            }
+            break;
+        case FillingStrategy.OUTER_PRIORITY:
+            {
+                const rows = maxedRows.slice();
+                while (rows.reduce((a, b) => a + b, 0) > nSeats) {
+                    rows.shift();
+                }
+                // here, rows represents the rows which will be fully filled,
+                // and their number of seats.
+                // this row will be only one to be partially filled
+                // the innermore ones are empty, the outermost ones are fully filled
+                startingRow = nRows - rows.length - 1;
+                seatsOnStartingRow = nSeats - rows.reduce((a, b) => a + b, 0);
+            }
+            break;
+        default:
+            throw new Error(`Invalid filling strategy: ${fillingStrategy}`);
+    }
+    const positions = new Map();
+    for (let r = startingRow; r < nRows; r++) {
+        let nSeatsThisRow;
+        if (r === nRows - 1) { // if it's the last, outermost row
+            // fit all the remaining seats
+            nSeatsThisRow = nSeats - positions.size;
+        }
+        else if (fillingStrategy === FillingStrategy.OUTER_PRIORITY) {
+            if (r === startingRow) {
+                nSeatsThisRow = seatsOnStartingRow;
+            }
+            else {
+                nSeatsThisRow = maxedRows[r];
+            }
+        }
+        else {
+            // fullness of the diagram times the maximal number of seats in this row
+            nSeatsThisRow = Math.round(fillingRatio * maxedRows[r]);
+            // actually more precise rounding : avoid rounding errors to accumulate too much
+            // nSeatsThisRow = Math.round((nSeats-positions.size) * maxedRows[r] / maxedRows.reduce((a, b) => a + b, 0));
+        }
+        // row radius : the radius of the circle crossing the center of each seat in the row
+        const rowArcRadius = .5 + 2 * r * rowThicc;
+        if (nSeatsThisRow === 1) {
+            positions.set([1, rowArcRadius], Math.PI / 2);
+        }
+        else {
+            // the angle necessary in this row to put the first (and last) seats fully on the canvas
+            const angleMargin = Math.asin(rowThicc / rowArcRadius)
+                // add the margin to make up the side angle
+                + spanAngleMargin;
+            // alternatively, allow the centers of the seats by the side to reach the angle's limits
+            // const angleMargin = Math.max(angleMargin, spanAngleMargin);
+            // the angle separating two seats on that row
+            const angleStep = (Math.PI - 2 * angleMargin) / (nSeatsThisRow - 1);
+            // a fraction of the remaining space, keeping in mind that the same elevation
+            // on start and end limits that remaining space to less than 2PI
+            for (let s = 0; s < nSeatsThisRow; s++) {
+                const angle = angleMargin + s * angleStep;
+                // an oriented angle, so it goes trig positive (counterclockwise)
+                positions.set([1 + rowArcRadius * Math.cos(angle), rowArcRadius * Math.sin(angle)], angle);
+            }
+        }
+    }
+    return positions;
+}
+//# sourceMappingURL=geometry.js.map

package/dist/geometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.js","sourceRoot":"","sources":["../src/geometry.ts"],"names":[],"mappings":"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"}

package/dist/utils.d.ts

@@ -0,0 +1,40 @@
+import { GetSeatCentersOptions } from "./geometry.js";
+type WithNumber<T> = T & {
+    readonly nSeats?: number | undefined;
+};
+/**
+ * Typically SeatLocation is a tuple of x/y coordinates, and SeatDisplay gives infos on what seats should look like.
+ * Typically the groups are ordered from the left to the right, and the seats are ordered from left to right.
+ * If too few or too many seats are provided, an error is thrown.
+ * @param attribution a mapping of groups associating the groups in a given order to the number of seats each group holds
+ * @param seats an iterable of seats in a given order, its length should be the sum of the values in attribution
+ * @returns a mapping of each group to the seats it holds
+ */
+export declare function dispatchSeats<SeatDisplay, SeatLocation>(attribution: ReadonlyMap<SeatDisplay, number> | readonly WithNumber<SeatDisplay>[], seats: Iterable<SeatLocation>): Map<SeatDisplay, SeatLocation[]>;
+type SeatCenter = readonly [number, number];
+type MappedSeatCenters<SeatDisplay, SeatLocation> = Iterable<readonly [SeatLocation, SeatDisplay]>;
+type GroupedSeatCenters<SeatDisplay, SeatLocation> = Iterable<readonly [SeatDisplay, readonly SeatLocation[]]>;
+/**
+ * Util function to convert seat centers representation
+ * @param seatCenters seating data oriented by seat center
+ * @returns grouped seat centers, organized by display, as taken by the component's input
+ */
+export declare function regroupSeatCenters<SeatDisplay, SeatLocation = SeatCenter>(seatCenters: MappedSeatCenters<SeatDisplay, SeatLocation>): GroupedSeatCenters<SeatDisplay, SeatLocation>;
+export interface PrecomputeOptions extends GetSeatCentersOptions {
+    seatRadiusFactor: number;
+}
+export interface PrecomputeReturn<SeatDisplay> {
+    groupedSeatCenters: Map<SeatDisplay, SeatCenter[]>;
+    seatActualRadius: number;
+}
+/**
+ * Pre-computes some values that are useful in the extensions that generate actual diagrams.
+ * The SeatDisplay type will depend on the extension.
+ * @param options.seatRadiusFactor the ratio (between 0 and 1) of the seat radius over the row thickness. Defaults to .8.
+ * @param options the rest of the options are those passed through to the options parameter of the getSeatCenters function.
+ * @returns an object with two properties:
+ * the groupedSeatCenters key, a mapping of SeatDisplay objects to the list of the corresponding seats' coordinates,
+ * and the seatActualRadius key, the actual radius of the seats (in the same unit as the coordinates)
+ */
+export declare function precomputeFromAttribution<SeatDisplay>(attribution: ReadonlyMap<SeatDisplay, number> | readonly WithNumber<SeatDisplay>[], options?: Partial<Readonly<PrecomputeOptions>>): PrecomputeReturn<SeatDisplay>;
+export {};

package/dist/utils.js

@@ -0,0 +1,70 @@
+import { getNRowsFromNSeats, getRowThickness, getSeatCenters } from "./geometry.js";
+const isReadonlyMap = v => v instanceof Map;
+/**
+ * Typically SeatLocation is a tuple of x/y coordinates, and SeatDisplay gives infos on what seats should look like.
+ * Typically the groups are ordered from the left to the right, and the seats are ordered from left to right.
+ * If too few or too many seats are provided, an error is thrown.
+ * @param attribution a mapping of groups associating the groups in a given order to the number of seats each group holds
+ * @param seats an iterable of seats in a given order, its length should be the sum of the values in attribution
+ * @returns a mapping of each group to the seats it holds
+ */
+export function dispatchSeats(attribution, seats) {
+    const seatIterator = seats[Symbol.iterator]();
+    const entries = isReadonlyMap(attribution) ?
+        Array.from(attribution) :
+        attribution.map(seatData => { var _a; return [seatData, (_a = seatData.nSeats) !== null && _a !== void 0 ? _a : 1]; });
+    try {
+        return new Map(entries.map(([group, nSeats]) => [group, Array.from({ length: nSeats }, () => {
+                const seatIteration = seatIterator.next();
+                if (seatIteration.done) {
+                    throw new Error("Not enough seats");
+                }
+                return seatIteration.value;
+            })]));
+    }
+    finally {
+        if (!seatIterator.next().done) {
+            throw new Error("Too many seats");
+        }
+    }
+}
+/**
+ * Util function to convert seat centers representation
+ * @param seatCenters seating data oriented by seat center
+ * @returns grouped seat centers, organized by display, as taken by the component's input
+ */
+export function regroupSeatCenters(seatCenters) {
+    const seatCentersByGroup = new Map();
+    for (const [seat, group] of seatCenters) {
+        if (!seatCentersByGroup.has(group)) {
+            seatCentersByGroup.set(group, []);
+        }
+        seatCentersByGroup.get(group).push(seat);
+    }
+    return seatCentersByGroup;
+}
+/**
+ * Pre-computes some values that are useful in the extensions that generate actual diagrams.
+ * The SeatDisplay type will depend on the extension.
+ * @param options.seatRadiusFactor the ratio (between 0 and 1) of the seat radius over the row thickness. Defaults to .8.
+ * @param options the rest of the options are those passed through to the options parameter of the getSeatCenters function.
+ * @returns an object with two properties:
+ * the groupedSeatCenters key, a mapping of SeatDisplay objects to the list of the corresponding seats' coordinates,
+ * and the seatActualRadius key, the actual radius of the seats (in the same unit as the coordinates)
+ */
+export function precomputeFromAttribution(attribution, options = {}) {
+    var _a;
+    if (!isReadonlyMap(attribution)) {
+        attribution = new Map(attribution.map(seatData => { var _a; return [seatData, (_a = seatData.nSeats) !== null && _a !== void 0 ? _a : 1]; }));
+    }
+    const seatRadiusFactor = (_a = options.seatRadiusFactor) !== null && _a !== void 0 ? _a : .8;
+    const nSeats = [...attribution.values()].reduce((a, b) => a + b, 0);
+    const results = getSeatCenters(nSeats, options);
+    const groupedSeatCenters = dispatchSeats(attribution, [...results.keys()].sort((a, b) => results.get(b) - results.get(a)));
+    const seatActualRadius = seatRadiusFactor * getRowThickness(getNRowsFromNSeats(nSeats, options.spanAngle));
+    return {
+        groupedSeatCenters,
+        seatActualRadius,
+    };
+}
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@parliamentarch/core",
+  "version": "4.0.0",
+  "description": "Tools to generate arch-styled parliamentary diagrams",
+  "type": "module",
+
+  "main": "./dist/geometry.js",
+  "types": "./dist/geometry.d.ts",
+  "exports": {
+    "./geometry": {
+      "import": {
+        "types": "./dist/geometry.d.ts",
+        "default": "./dist/geometry.js"
+      }
+    },
+    "./utils": {
+      "import": {
+        "types": "./dist/utils.d.ts",
+        "default": "./dist/utils.js"
+      }
+    }
+  },
+
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "node ../../scripts/clean.ts -d ./dist",
+    "compile": "tsc",
+    "build": "npm run clean & npm run compile",
+    "pub": "npm run build & npm publish --access public",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+
+  "devDependencies": {
+    "@tsconfig/strictest": "^2.0.8",
+    "typescript": "^6.0.2"
+  },
+
+  "author": "Gouvernathor",
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "https://codeberg.org/Gouvernathor/ParliamentArch-TS.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://codeberg.org/Gouvernathor/ParliamentArch-TS/src/packages/core#readme",
+  "bugs": {
+    "url": "https://github.com/Gouvernathor/ParliamentArch-TS/issues"
+  },
+  "funding": "https://ko-fi.com/gouvernathor",
+  "keywords": [
+    "parliament",
+    "diagram",
+    "arch",
+    "hemicycle",
+    "svg"
+  ]
+}