@edubeam/plot 0.1.0 → 0.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +88 -0
- package/dist/components/StructurePlot.vue.d.ts +1 -2
- package/dist/components/texts.d.ts +24 -0
- package/dist/components/theme.d.ts +3 -3
- package/dist/components/types.d.ts +12 -2
- package/dist/core/layout.d.ts +23 -0
- package/dist/core/model.d.ts +4 -1
- package/dist/core/polynomial.d.ts +0 -1
- package/dist/core/readout.d.ts +59 -7
- package/dist/core/scene.d.ts +73 -6
- package/dist/core/structure.d.ts +151 -5
- package/dist/core/svg.d.ts +76 -0
- package/dist/index.d.ts +6 -3
- package/dist/index.js +2282 -1231
- package/dist/index.js.map +1 -1
- package/package.json +1 -1
package/dist/core/structure.d.ts
CHANGED
|
@@ -2,18 +2,25 @@
|
|
|
2
2
|
* The drawing of a whole structure as scene items, in the hand of the EduBeam website's figures
|
|
3
3
|
* (HeroFigure, BuildSteps): ink members with round caps, outlined supports, orange loads, purple
|
|
4
4
|
* reactions clear of the supports, diagrams as an outline with ordinates across the member, and
|
|
5
|
-
* numbers
|
|
5
|
+
* numbers where a reader looks for them - member ends, steps, extremes and corners.
|
|
6
6
|
*
|
|
7
7
|
* Sign rules follow the EduBeam app: N and V positive away from the member's local +z side, M on
|
|
8
8
|
* the tension side, so a sagging moment hangs below a beam drawn left to right.
|
|
9
9
|
*/
|
|
10
|
-
import { type InternalForce, type MemberFrame, type PlotModel } from './model.js';
|
|
10
|
+
import { type InternalForce, type MemberFrame, type MemberResults, type PlotModel } from './model.js';
|
|
11
11
|
import { type Anchor, type SceneItem, type TextPlacement } from './scene.js';
|
|
12
12
|
import { type Units } from './units.js';
|
|
13
13
|
/** What the caller switches on and off. Results are named by their symbol. */
|
|
14
|
-
export type PlotLayer = 'nodes' | 'nodeLabels' | 'dimensions' | 'members' | 'supports' | 'loads' | 'reactions' | 'N' | 'V' | 'M' | 'w';
|
|
14
|
+
export type PlotLayer = 'nodes' | 'nodeLabels' | 'memberLabels' | 'dimensions' | 'members' | 'supports' | 'loads' | 'reactions' | 'N' | 'V' | 'M' | 'w';
|
|
15
15
|
/** Every layer, in paint order: results under the structure, nodes on top as BuildSteps draws them. */
|
|
16
16
|
export declare const PLOT_LAYERS: readonly PlotLayer[];
|
|
17
|
+
export interface TemperatureSymbols {
|
|
18
|
+
/** The uniform change, along the axis */
|
|
19
|
+
readonly uniform: string;
|
|
20
|
+
/** The difference across the depth, bottom minus top */
|
|
21
|
+
readonly gradient: string;
|
|
22
|
+
}
|
|
23
|
+
export declare const DEFAULT_TEMPERATURE_SYMBOLS: TemperatureSymbols;
|
|
17
24
|
export declare const RESULT_LAYERS: readonly ["N", "V", "M", "w"];
|
|
18
25
|
export type ResultLayer = (typeof RESULT_LAYERS)[number];
|
|
19
26
|
export interface StructureSceneOptions {
|
|
@@ -21,8 +28,55 @@ export interface StructureSceneOptions {
|
|
|
21
28
|
readonly layers: ReadonlySet<PlotLayer>;
|
|
22
29
|
/** Thumbnail drawing: smaller symbols, at most two values per member, magnitudes only. */
|
|
23
30
|
readonly compact: boolean;
|
|
31
|
+
/**
|
|
32
|
+
* Sizes in place of the preset's (full or compact), px: an editor draws its members lighter, its
|
|
33
|
+
* arrows shorter and alike for loads and reactions, its moments as a nearly closed ring.
|
|
34
|
+
*/
|
|
35
|
+
readonly sizes?: Partial<SymbolSizes>;
|
|
36
|
+
/**
|
|
37
|
+
* How loads are written. `figure` (the default): with their units, a uniform load once as
|
|
38
|
+
* `q = …`. `ends`: as an editor annotates them, bare numbers (its units shown elsewhere), and a
|
|
39
|
+
* distributed load at both its ends, zero included, as students are taught to write it.
|
|
40
|
+
*/
|
|
41
|
+
readonly loadLabels?: 'figure' | 'ends';
|
|
42
|
+
/**
|
|
43
|
+
* A diagram constant along its member: its value `once`, mid-member (the default), or at both
|
|
44
|
+
* `ends`, as students are taught to annotate every segment.
|
|
45
|
+
*/
|
|
46
|
+
readonly constantDiagrams?: 'once' | 'ends';
|
|
47
|
+
/**
|
|
48
|
+
* A moment the same round a rigid corner: written `once` (the default), at the member with the
|
|
49
|
+
* most room, or at `each` member's end, as students annotate every member.
|
|
50
|
+
*/
|
|
51
|
+
readonly cornerValues?: 'once' | 'each';
|
|
52
|
+
/** Labels keep off the support symbols too, not only the members and arrows. */
|
|
53
|
+
readonly labelsAvoidSupports?: boolean;
|
|
54
|
+
/**
|
|
55
|
+
* Nodes no member reaches are drawn too, with their names and supports: an editor's nodes, placed
|
|
56
|
+
* before they are connected. By default a figure leaves them out.
|
|
57
|
+
*/
|
|
58
|
+
readonly freeNodes?: boolean;
|
|
59
|
+
/**
|
|
60
|
+
* A distributed load with both components drawn as the two loads it was entered as (along and
|
|
61
|
+
* across the member for a local load, x and z for a global one), each with its own value, rather
|
|
62
|
+
* than as their resultant.
|
|
63
|
+
*/
|
|
64
|
+
readonly splitLoads?: boolean;
|
|
65
|
+
/**
|
|
66
|
+
* Values of different diagrams on one ordinate line, written along it, stand side by side there,
|
|
67
|
+
* each half a line aside, rather than one pushed further out (see `sideBySide`).
|
|
68
|
+
*/
|
|
69
|
+
readonly sideBySide?: boolean;
|
|
24
70
|
readonly units: Units;
|
|
25
71
|
readonly numberFormat?: Intl.NumberFormat;
|
|
72
|
+
/**
|
|
73
|
+
* Writes a displacement, given in display units. Displacements are orders of magnitude smaller
|
|
74
|
+
* than the forces, so an editor writes them its own way (a power of ten where `numberFormat`'s
|
|
75
|
+
* fixed decimals would round a deflection to zero).
|
|
76
|
+
*/
|
|
77
|
+
readonly displacementText?: (value: number) => string;
|
|
78
|
+
/** The temperature load's symbols, which apps write differently: the Czech EduBeam has ΔTs and ΔTd − ΔTh. */
|
|
79
|
+
readonly temperatureSymbols?: TemperatureSymbols;
|
|
26
80
|
/** Current scale in px per metre: spaces ordinates and load arrows evenly on screen. */
|
|
27
81
|
readonly scale: number;
|
|
28
82
|
/** Largest diagram ordinate, px. */
|
|
@@ -33,27 +87,119 @@ export interface StructureSceneOptions {
|
|
|
33
87
|
readonly diagramScale?: Partial<Record<ResultLayer, number>>;
|
|
34
88
|
/** M on the tension side (most of Europe); off draws it on the compression side. */
|
|
35
89
|
readonly momentOnTensionSide: boolean;
|
|
90
|
+
/** Positive N on the member's dashed side (local +z); off (the default), on the other. */
|
|
91
|
+
readonly normalOnDashedSide?: boolean;
|
|
92
|
+
/** Positive V on the member's dashed side (local +z); off (the default), on the other. */
|
|
93
|
+
readonly shearOnDashedSide?: boolean;
|
|
94
|
+
/**
|
|
95
|
+
* How a diagram's area is drawn: `hatch` (the default), lines across the member as drawn by
|
|
96
|
+
* hand; `solid`, a light tint; `none`, the outline alone.
|
|
97
|
+
*/
|
|
98
|
+
readonly diagramFill?: 'hatch' | 'solid' | 'none';
|
|
99
|
+
/** Write each piece's polynomial degree inside the diagram: 0°, 1°, 2°, 3°. */
|
|
100
|
+
readonly showDegrees?: boolean;
|
|
101
|
+
/** Support symbols' size, as a multiple of the preset's (the editor's support size setting). */
|
|
102
|
+
readonly supportScale?: number;
|
|
36
103
|
/** The plot's font size, px: labels in a tight spot may step down from it to 10 px. */
|
|
37
104
|
readonly fontSize?: number;
|
|
38
105
|
/** Values upright (`horizontal`) or turned to run along their ordinate (`axis`), as in the app. */
|
|
39
106
|
readonly resultLabelMode?: ResultLabelMode;
|
|
107
|
+
/**
|
|
108
|
+
* `values` (the default) draws each reaction the way it acts, with its size. `names` draws the
|
|
109
|
+
* unknowns of an exercise instead: an arrow for every restrained direction, pointing the way it
|
|
110
|
+
* counts as positive (along the node's x, up, counter-clockwise), named `A` with subscript `x`,
|
|
111
|
+
* `z`, or `M` with subscript `A`. It needs no results.
|
|
112
|
+
*/
|
|
113
|
+
readonly reactionLabels?: ReactionLabels;
|
|
40
114
|
}
|
|
41
115
|
export type ResultLabelMode = 'axis' | 'horizontal';
|
|
116
|
+
export type ReactionLabels = 'values' | 'names';
|
|
42
117
|
/** Ordinates are this far apart on screen, as in the app and the website's figures. */
|
|
43
118
|
export declare const HATCH_SPACING_PX = 7;
|
|
119
|
+
/** Symbol sizes in px: the website's figures, and a smaller set for thumbnails. */
|
|
120
|
+
declare const SIZES: {
|
|
121
|
+
readonly full: {
|
|
122
|
+
readonly member: 3.5;
|
|
123
|
+
/** A hinge's circle, radius: its own size, so a lighter member keeps a readable hinge */
|
|
124
|
+
readonly hinge: 4.5;
|
|
125
|
+
/** A moment load's arc: how far round it runs, its weight and its head */
|
|
126
|
+
readonly arcSweep: 270;
|
|
127
|
+
readonly arcWidth: 1.75;
|
|
128
|
+
readonly arcHead: 8;
|
|
129
|
+
readonly arcHeadHalf: 3.5;
|
|
130
|
+
readonly pointShaft: 3;
|
|
131
|
+
readonly pointHead: 12;
|
|
132
|
+
readonly pointHeadWidth: 14;
|
|
133
|
+
readonly pointArrow: 52;
|
|
134
|
+
readonly udlArrow: 32;
|
|
135
|
+
readonly udlSpacing: 18;
|
|
136
|
+
readonly reaction: 46;
|
|
137
|
+
readonly reactionShaft: 1.75;
|
|
138
|
+
readonly reactionHead: 9;
|
|
139
|
+
readonly reactionHeadWidth: 9;
|
|
140
|
+
readonly reactionGap: 11;
|
|
141
|
+
/** A reaction's arrow clear of a moment's ring round the same node */
|
|
142
|
+
readonly reactionArcGap: 8;
|
|
143
|
+
/** A node's label from the node, and from it when a moment's ring surrounds it */
|
|
144
|
+
readonly nodeLabelGap: 9;
|
|
145
|
+
readonly arcLabelGap: 24;
|
|
146
|
+
readonly arcLabelFirst: 24;
|
|
147
|
+
readonly arc: 15;
|
|
148
|
+
readonly reactionArc: 20;
|
|
149
|
+
/** A moment reaction's arc: a half circle on the support's side, clear of the diagrams */
|
|
150
|
+
readonly reactionArcSweep: 190;
|
|
151
|
+
readonly deformed: 2.25;
|
|
152
|
+
};
|
|
153
|
+
readonly compact: {
|
|
154
|
+
readonly member: 2.75;
|
|
155
|
+
readonly hinge: 3.75;
|
|
156
|
+
readonly arcSweep: 270;
|
|
157
|
+
readonly arcWidth: 1.75;
|
|
158
|
+
readonly arcHead: 8;
|
|
159
|
+
readonly arcHeadHalf: 3.5;
|
|
160
|
+
readonly pointShaft: 2.25;
|
|
161
|
+
readonly pointHead: 9;
|
|
162
|
+
readonly pointHeadWidth: 10;
|
|
163
|
+
readonly pointArrow: 34;
|
|
164
|
+
readonly udlArrow: 22;
|
|
165
|
+
readonly udlSpacing: 14;
|
|
166
|
+
readonly reaction: 32;
|
|
167
|
+
readonly reactionShaft: 1.75;
|
|
168
|
+
readonly reactionHead: 9;
|
|
169
|
+
readonly reactionHeadWidth: 9;
|
|
170
|
+
readonly reactionGap: 8;
|
|
171
|
+
readonly reactionArcGap: 8;
|
|
172
|
+
readonly nodeLabelGap: 9;
|
|
173
|
+
readonly arcLabelGap: 24;
|
|
174
|
+
readonly arcLabelFirst: 24;
|
|
175
|
+
readonly arc: 11;
|
|
176
|
+
readonly reactionArc: 15;
|
|
177
|
+
readonly reactionArcSweep: 190;
|
|
178
|
+
readonly deformed: 1.75;
|
|
179
|
+
};
|
|
180
|
+
};
|
|
181
|
+
/** Every symbol's size, px: line weights, arrow lengths and heads, arcs. */
|
|
182
|
+
export type SymbolSizes = {
|
|
183
|
+
readonly [K in keyof (typeof SIZES)['full']]: number;
|
|
184
|
+
};
|
|
44
185
|
type Vec = {
|
|
45
186
|
readonly x: number;
|
|
46
187
|
readonly y: number;
|
|
47
188
|
};
|
|
48
189
|
/** Which way a positive value is drawn, along the member's local z: +1 toward local +z. */
|
|
49
|
-
export declare const diagramSide: (q: InternalForce, momentOnTensionSide: boolean
|
|
190
|
+
export declare const diagramSide: (q: InternalForce, momentOnTensionSide: boolean, dashed?: {
|
|
191
|
+
readonly normalOnDashedSide?: boolean;
|
|
192
|
+
readonly shearOnDashedSide?: boolean;
|
|
193
|
+
}) => 1 | -1;
|
|
50
194
|
/**
|
|
51
195
|
* Where a value goes: just beyond the tip of the ordinate it denotes, along that ordinate, so it
|
|
52
196
|
* reads as the ordinate's continuation. With `axis` the text turns to run along the ordinate
|
|
53
197
|
* (across the member), as the app writes it, never upside down. Each further place moves it
|
|
54
198
|
* outward along the same ordinate - it never leaves its tip.
|
|
55
199
|
*/
|
|
56
|
-
export declare const tipPlacements: (tip: Anchor, out: Vec, mode: ResultLabelMode, gaps?: number[]) => TextPlacement[];
|
|
200
|
+
export declare const tipPlacements: (tip: Anchor, out: Vec, mode: ResultLabelMode, gaps?: readonly number[], asides?: readonly number[]) => TextPlacement[];
|
|
201
|
+
/** Every member carries one constant normal force and no member loads: a truss, read bar by bar. */
|
|
202
|
+
export declare const isBarStructure: (model: PlotModel, results: Readonly<Record<string, MemberResults>>) => boolean;
|
|
57
203
|
/** px per SI unit for each result, from the largest value anywhere in the structure. */
|
|
58
204
|
export declare const diagramScales: (model: PlotModel, options: Pick<StructureSceneOptions, "diagramSize" | "deformedSize" | "diagramScale">) => Record<ResultLayer, number>;
|
|
59
205
|
export declare const memberFrames: (model: PlotModel) => Map<string, MemberFrame>;
|
|
@@ -0,0 +1,76 @@
|
|
|
1
|
+
import type { PlotModel } from './model.js';
|
|
2
|
+
import { type ResolvedScene, type Tone } from './scene.js';
|
|
3
|
+
import { type PlotLayer, type ReactionLabels, type ResultLabelMode, type TemperatureSymbols } from './structure.js';
|
|
4
|
+
import { type Units } from './units.js';
|
|
5
|
+
/** Concrete colours for a file that has no page around it: the EduBeam app's, on white. */
|
|
6
|
+
export declare const PRINT_COLORS: Readonly<Record<Tone | 'paper', string>>;
|
|
7
|
+
export interface StructureSvgOptions {
|
|
8
|
+
/** Layers to draw. Default: members, supports, loads, reactions and the result `StructurePlot` picks. */
|
|
9
|
+
readonly layers?: readonly PlotLayer[];
|
|
10
|
+
/**
|
|
11
|
+
* Layers to make room for besides `layers`, as `StructurePlot`'s `reserve`: give every stage of a
|
|
12
|
+
* build-up the last stage's layers, and the files line up when laid over each other (Beamer overlays).
|
|
13
|
+
*/
|
|
14
|
+
readonly reserve?: readonly PlotLayer[];
|
|
15
|
+
/** Label styles to make room for besides `resultLabelMode`. */
|
|
16
|
+
readonly reserveLabelModes?: readonly ResultLabelMode[];
|
|
17
|
+
/** Reaction label styles to make room for besides `reactionLabels`, so a sheet and its key line up. */
|
|
18
|
+
readonly reserveReactionLabels?: readonly ReactionLabels[];
|
|
19
|
+
/** Width of the drawing, px (the SVG's user units). Default 640. */
|
|
20
|
+
readonly width?: number;
|
|
21
|
+
/** Fixed height, px; by default the height follows the drawing, up to `maxHeight`. */
|
|
22
|
+
readonly height?: number;
|
|
23
|
+
readonly maxHeight?: number;
|
|
24
|
+
readonly padding?: number;
|
|
25
|
+
readonly fontSize?: number;
|
|
26
|
+
/** Any font stack the program opening the file knows. */
|
|
27
|
+
readonly fontFamily?: string;
|
|
28
|
+
readonly compact?: boolean;
|
|
29
|
+
readonly units?: Partial<Units>;
|
|
30
|
+
readonly numberFormat?: Intl.NumberFormat;
|
|
31
|
+
/** The temperature load's symbols, `ΔT` and `ΔTb − ΔTt` unless given */
|
|
32
|
+
readonly temperatureSymbols?: TemperatureSymbols;
|
|
33
|
+
readonly colors?: Partial<Record<Tone | 'paper', string>>;
|
|
34
|
+
readonly diagramSize?: number;
|
|
35
|
+
readonly deformedSize?: number;
|
|
36
|
+
readonly momentOnTensionSide?: boolean;
|
|
37
|
+
readonly resultLabelMode?: ResultLabelMode;
|
|
38
|
+
/** `names` draws the reactions as an exercise's unknowns, as `StructurePlot`'s `reactionLabels`. */
|
|
39
|
+
readonly reactionLabels?: ReactionLabels;
|
|
40
|
+
/** Paint the background in `paper`; off leaves it transparent. Default on. */
|
|
41
|
+
readonly background?: boolean;
|
|
42
|
+
/** Accessible name, written as the SVG's `<title>`. */
|
|
43
|
+
readonly title?: string;
|
|
44
|
+
}
|
|
45
|
+
/**
|
|
46
|
+
* The plot of a model as the text of a standalone `.svg` file, laid out as `StructurePlot` lays it
|
|
47
|
+
* out. Labels carry their halo as a separate text drawn underneath, for programs that ignore
|
|
48
|
+
* `paint-order`.
|
|
49
|
+
*/
|
|
50
|
+
export declare const structureSvg: (model: PlotModel, options?: StructureSvgOptions) => string;
|
|
51
|
+
export interface SceneSvgOptions {
|
|
52
|
+
readonly colors?: Partial<Record<Tone | 'paper', string>>;
|
|
53
|
+
/** The labels' size where a label has none of its own, px. Default 13. */
|
|
54
|
+
readonly fontSize?: number;
|
|
55
|
+
readonly fontFamily?: string;
|
|
56
|
+
/** Paint the background in `paper`; off leaves it transparent. Default on. */
|
|
57
|
+
readonly background?: boolean;
|
|
58
|
+
/** Accessible name, written as the SVG's `<title>`. */
|
|
59
|
+
readonly title?: string;
|
|
60
|
+
}
|
|
61
|
+
/** How a scene's shapes and labels are written: its colours and its labels' size. */
|
|
62
|
+
export type SceneMarkupOptions = Pick<SceneSvgOptions, 'colors' | 'fontSize'>;
|
|
63
|
+
/**
|
|
64
|
+
* A scene already laid out, as SVG markup without the root element: its shapes layer by layer in
|
|
65
|
+
* paint order, then every label, each with its halo as a text of its own underneath (for programs
|
|
66
|
+
* that ignore `paint-order`). For an application that places the drawing in an SVG of its own.
|
|
67
|
+
*/
|
|
68
|
+
export declare const sceneMarkup: (resolved: Pick<ResolvedScene, "paths" | "circles" | "texts">, options?: SceneMarkupOptions) => string;
|
|
69
|
+
/**
|
|
70
|
+
* A scene already laid out, as the text of a standalone `.svg` file of the given size: for an
|
|
71
|
+
* application that lays a structure out its own way and saves it as `structureSvg` saves its own.
|
|
72
|
+
*/
|
|
73
|
+
export declare const sceneSvg: (resolved: Pick<ResolvedScene, "paths" | "circles" | "texts">, size: {
|
|
74
|
+
readonly width: number;
|
|
75
|
+
readonly height: number;
|
|
76
|
+
}, options?: SceneSvgOptions) => string;
|
package/dist/index.d.ts
CHANGED
|
@@ -3,12 +3,15 @@ export { default as DiagramStack } from './components/DiagramStack.vue.js';
|
|
|
3
3
|
export { DEFAULT_COLORS, PLOT_CSS, toneVars, type PlotColors } from './components/theme.js';
|
|
4
4
|
export type { DiagramStackEmits, DiagramStackProps, StackReadout, StructurePlotEmits, StructurePlotProps, } from './components/types.js';
|
|
5
5
|
export { EduBeamPlot } from './plugin.js';
|
|
6
|
+
export { DEFAULT_PLOT_TEXTS, PLOT_TEXTS, usePlotTexts, type PlotTexts } from './components/texts.js';
|
|
6
7
|
export { modelFromSolver, type FromSolverOptions } from './core/fromSolver.js';
|
|
8
|
+
export { layoutStructure, alternativeResultGroups, type StructureLayout } from './core/layout.js';
|
|
9
|
+
export { structureSvg, sceneSvg, sceneMarkup, PRINT_COLORS, type StructureSvgOptions, type SceneSvgOptions, type SceneMarkupOptions, } from './core/svg.js';
|
|
7
10
|
export * from './core/model.js';
|
|
8
11
|
export * from './core/polynomial.js';
|
|
9
12
|
export * from './core/units.js';
|
|
10
13
|
export { supportKind, supportPlacement, supportGlyph, glyphReach, type SupportKind, type SupportPlacement, type GlyphPart, } from './core/supports.js';
|
|
11
|
-
export { buildStructureScene, defaultResultLayer, diagramScales, diagramSide, memberFrames, HATCH_SPACING_PX, PLOT_LAYERS, RESULT_LAYERS, type PlotLayer, type ResultLabelMode, type ResultLayer, type StructureSceneOptions, tipPlacements, } from './core/structure.js';
|
|
12
|
-
export { fitScene, placeLabels, resolveScene, sceneBounds, project, type Anchor, type Fit, type FitBox, type SceneItem, type ResolvedScene, type Transform, type Tone, } from './core/scene.js';
|
|
13
|
-
export { readMember, readoutAt, formatReadout, type Readout, type ReadoutQuantity, type SidedValue, } from './core/readout.js';
|
|
14
|
+
export { buildStructureScene, defaultResultLayer, diagramScales, diagramSide, isBarStructure, memberFrames, HATCH_SPACING_PX, DEFAULT_TEMPERATURE_SYMBOLS, PLOT_LAYERS, RESULT_LAYERS, type PlotLayer, type TemperatureSymbols, type ReactionLabels, type ResultLabelMode, type ResultLayer, type StructureSceneOptions, type SymbolSizes, tipPlacements, } from './core/structure.js';
|
|
15
|
+
export { fitScene, placeLabels, resolveScene, mergePaths, sceneBounds, project, type Anchor, type Fit, type FitBox, type SceneItem, type ResolvedScene, type ResolvedPath, type ResolvedText, type ResolvedCircle, type ResolveOptions, type SceneText, type Bounds, type TextPlacement, type Transform, type Tone, } from './core/scene.js';
|
|
16
|
+
export { readMember, readoutAt, readoutMarks, formatReadout, placeReadoutTags, type ReadoutTag, type Readout, type ReadoutMark, type ReadoutQuantity, type SidedValue, } from './core/readout.js';
|
|
14
17
|
export { beamLine, lineDiagram, lineModel, pointLoadAt, rowOutline, rowOrdinates, rowRange, rowPeaks, rowBreaks, type BeamLine, type LineMember, type RowPeak, type StackRow, } from './core/stack.js';
|