@pie-element/number-line 13.1.1 → 13.1.2-next.1

package/dist/delivery/number-line/graph/index.js

@@ -0,0 +1,196 @@
+import { snapTo as e } from "./tick-utils.js";
+import t from "./elements/point.js";
+import n from "./elements/line.js";
+import r from "./arrow.js";
+import i from "./elements/ray.js";
+import a from "./line.js";
+import o from "./ticks.js";
+import s from "./stacks.js";
+import c from "../transitions/fade.js";
+import l, { createElement as u } from "react";
+import d from "prop-types";
+import { jsx as f, jsxs as p } from "react/jsx-runtime";
+import { scaleLinear as m } from "d3-scale";
+import { pointer as h, select as g } from "d3-selection";
+import { color as _ } from "@pie-lib/render-ui";
+import { DndContext as v } from "@dnd-kit/core";
+import { TransitionGroup as y } from "react-transition-group";
+//#region src/delivery/number-line/graph/index.tsx
+var b = (e, t, n, r) => {
+	if (e === void 0 || t === void 0 || n === void 0) throw Error("missing min/max/width");
+	return m().domain([e, t]).range([r, n - r]);
+}, x = class extends l.Component {
+	static childContextTypes = {
+		xScale: d.func.isRequired,
+		snapValue: d.func.isRequired
+	};
+	static propTypes = {
+		domain: d.shape({
+			min: d.number.isRequired,
+			max: d.number.isRequired
+		}).isRequired,
+		ticks: d.shape({
+			minor: d.number,
+			major: d.number
+		}).isRequired,
+		fraction: d.bool,
+		width: d.number.isRequired,
+		height: d.number.isRequired,
+		onToggleElement: d.func.isRequired,
+		onMoveElement: d.func.isRequired,
+		onAddElement: d.func.isRequired,
+		debug: d.bool,
+		elements: d.array,
+		disabled: d.bool,
+		onDeselectElements: d.func,
+		arrows: d.shape({
+			left: d.bool,
+			right: d.bool
+		})
+	};
+	static defaultProps = { debug: !1 };
+	constructor(e) {
+		super(e), this.state = {};
+	}
+	xScaleFn() {
+		let { domain: e, width: t } = this.props, { max: n, min: r } = e || {}, i = 20;
+		return n && (i = n.toString().length * 4 + 15), b(r, n, t, i);
+	}
+	snapValueFn() {
+		let { domain: t, ticks: n } = this.props;
+		return e.bind(null, t.min, t.max, n.minor);
+	}
+	getChildContext() {
+		return {
+			xScale: this.xScaleFn(),
+			snapValue: this.snapValueFn()
+		};
+	}
+	onRectClick(e) {
+		let { elements: t, disabled: n } = this.props;
+		if (!n) if (t.some((e) => e.selected)) this.props.onDeselectElements();
+		else {
+			let t = h(e, this.rect), n = this.xScaleFn().invert(t[0]);
+			this.addElement(n);
+		}
+	}
+	componentDidMount() {
+		g(this.rect).on("click", this.onRectClick.bind(this));
+	}
+	addElement(e) {
+		let t = this.snapValueFn()(e);
+		this.props.onAddElement(t);
+	}
+	render() {
+		let { domain: e, width: l, ticks: d, height: m, onToggleElement: h, onMoveElement: g, disabled: b, fraction: x } = this.props, { arrows: S } = this.props;
+		S ||= {
+			left: !0,
+			right: !0
+		};
+		let { min: C, max: w } = e;
+		if (e.max <= e.min) return /* @__PURE__ */ p("div", { children: [
+			e.max,
+			" is less than or equal to ",
+			e.min
+		] });
+		{
+			let T = m - 30, E = new s(e), D = this.props.elements.map((e, r) => {
+				let a = E.add(e);
+				if (a === -1) throw Error("stack index is -1, cant add element");
+				let o = {
+					key: r,
+					y: T - a * 25,
+					selected: e.selected && !b,
+					interval: d.minor,
+					disabled: b,
+					correct: e.correct
+				}, s = h.bind(null, r, e), c = g.bind(null, r, e);
+				if (e.type === "line") {
+					let t = {
+						left: e.leftPoint === "empty",
+						right: e.rightPoint === "empty"
+					};
+					return /* @__PURE__ */ u(n, {
+						...o,
+						domain: {
+							min: C,
+							max: w
+						},
+						onMoveLine: c,
+						onToggleSelect: s,
+						position: e.position,
+						empty: t,
+						key: r
+					});
+				} else if (e.type === "point") {
+					let n = {
+						left: C - e.position,
+						right: w - e.position
+					};
+					return /* @__PURE__ */ u(t, {
+						...o,
+						empty: e.pointType === "empty",
+						position: e.position,
+						bounds: n,
+						onClick: s,
+						onMove: c,
+						key: r
+					});
+				} else if (e.type === "ray") return /* @__PURE__ */ u(i, {
+					...o,
+					domain: {
+						min: C,
+						max: w
+					},
+					direction: e.direction,
+					position: e.position,
+					onMove: c,
+					onToggleSelect: s,
+					width: l,
+					empty: e.pointType === "empty",
+					key: r
+				});
+			});
+			return /* @__PURE__ */ f(v, { children: /* @__PURE__ */ f("div", {
+				style: { display: "inline-block" },
+				children: /* @__PURE__ */ p("svg", {
+					width: l,
+					height: x ? m + 20 : m,
+					children: [
+						!1,
+						/* @__PURE__ */ f(a, {
+							y: T,
+							width: l
+						}),
+						S.left && /* @__PURE__ */ f(r, { y: T }),
+						S.right && /* @__PURE__ */ f(r, {
+							x: l,
+							y: T,
+							direction: "right"
+						}),
+						/* @__PURE__ */ f(o, {
+							y: T,
+							domain: e,
+							width: l,
+							ticks: d,
+							fraction: x
+						}),
+						/* @__PURE__ */ f("rect", {
+							ref: (e) => this.rect = e,
+							fill: _.primary(),
+							fillOpacity: "0.0",
+							width: l,
+							height: m
+						}),
+						/* @__PURE__ */ f(y, {
+							component: "g",
+							children: D.map((e, t) => /* @__PURE__ */ f(c, { children: e }, t))
+						})
+					]
+				})
+			}) });
+		}
+	}
+};
+//#endregion
+export { x as default };

package/dist/delivery/number-line/graph/line.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @synced-from pie-elements/packages/number-line/src/number-line/graph/line.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+import React from 'react';
+import PropTypes from 'prop-types';
+export declare function Line({ y, width, classes }: {
+    y: any;
+    width: any;
+    classes: any;
+}): React.JSX.Element;
+export declare namespace Line {
+    var propTypes: {
+        y: PropTypes.Validator<number>;
+        width: PropTypes.Validator<number>;
+        classes: PropTypes.Validator<object>;
+    };
+}
+declare const _default: React.ComponentType<Pick<Omit<{
+    y: any;
+    width: any;
+    classes: any;
+}, "classes"> & {
+    classes?: Partial<{
+        root: string;
+    }> | undefined;
+    innerRef?: React.RefObject<any> | ((instance: any) => void);
+}, "classes" | "innerRef"> & Pick<PropTypes.InferProps<{
+    y: PropTypes.Validator<number>;
+    width: PropTypes.Validator<number>;
+    classes: PropTypes.Validator<object>;
+}>, "y" | "width"> & Pick<Omit<{
+    y: any;
+    width: any;
+    classes: any;
+}, "classes"> & {
+    classes?: Partial<{
+        root: string;
+    }> | undefined;
+    innerRef?: React.RefObject<any> | ((instance: any) => void);
+}, "innerRef">>;
+export default _default;

package/dist/delivery/number-line/graph/line.js

@@ -0,0 +1,27 @@
+import "react";
+import e from "prop-types";
+import { jsx as t } from "react/jsx-runtime";
+import { color as n } from "@pie-lib/render-ui";
+import r from "react-jss";
+//#region src/delivery/number-line/graph/line.tsx
+var i = { root: {
+	strokeWidth: 2,
+	stroke: n.primary()
+} };
+function a({ y: e, width: n, classes: r }) {
+	return /* @__PURE__ */ t("line", {
+		x1: 0,
+		y1: e,
+		x2: n,
+		y2: e,
+		className: r.root
+	});
+}
+a.propTypes = {
+	y: e.number.isRequired,
+	width: e.number.isRequired,
+	classes: e.object.isRequired
+};
+var o = r(i)(a);
+//#endregion
+export { o as default };

package/dist/delivery/number-line/graph/stacks.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @synced-from pie-elements/packages/number-line/src/number-line/graph/stacks.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+export default function Stacks(domain: any): void;
+export declare function Stack(domain: any): void;

package/dist/delivery/number-line/graph/stacks.js

@@ -0,0 +1,40 @@
+//#region src/delivery/number-line/graph/stacks.ts
+function e(e) {
+	let n = [new t(e)];
+	this.add = function(r) {
+		let i = n.find((e) => e.add(r));
+		return n.indexOf(i) === -1 && (i = new t(e), n.push(i), i.add(r)), n.indexOf(i);
+	};
+}
+function t(e) {
+	let t = [];
+	this.add = function(i) {
+		let a = r(i);
+		return a.left < e.min || a.right > e.max || t.some((e) => n(e, a)) ? !1 : (t.push(i), !0);
+	}, this.elements = function() {
+		return t;
+	};
+	let n = (e, t) => {
+		let n = r(e), i = t.left < n.left && t.right < n.left, a = t.left > n.right && t.right > n.right;
+		return !(i || a);
+	}, r = (t) => {
+		let { type: n, position: r } = t;
+		switch (n) {
+			case "point": return {
+				left: r,
+				right: r
+			};
+			case "line": return r;
+			case "ray": return t.direction === "positive" ? {
+				left: r,
+				right: e.max
+			} : {
+				left: e.min,
+				right: r
+			};
+			default: return null;
+		}
+	};
+}
+//#endregion
+export { e as default };

package/dist/delivery/number-line/graph/tick-utils.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @synced-from pie-elements/packages/number-line/src/number-line/graph/tick-utils.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+import * as math from 'mathjs';
+export declare const decimalTickValues: number[];
+export declare const fractionTickValues: string[];
+export declare const labelMultiplier: {
+    1: number[];
+    2: number[];
+    3: number[];
+    4: number[];
+    5: number[];
+    6: number[];
+    7: number[];
+    8: number[];
+    9: number[];
+    10: number[];
+    12: number[];
+    15: number[];
+    16: number[];
+    20: number[];
+    25: number[];
+    32: number[];
+    50: number[];
+    64: number[];
+    100: number[];
+    1000: number[];
+};
+export declare const fractionRange: (start: any, end: any, interval: any) => any[];
+export declare const zbrErrorMessage: (start: any, end: any) => string;
+export declare const zeroBasedRange: (start: any, end: any, interval: any) => any[];
+/**
+ * the lodash range was causing too much variance in the rounding errors
+ * such that it was hard to round the numbers.
+ * This is a more simplistic version but makes rounding work.
+ */
+export declare const simpleRange: (start: any, end: any, interval: any) => (string | math.MathType)[];
+export declare const closeTo: (a: any, b: any, precision: any) => boolean;
+export declare const getMinorLimits: (domain: any, width: any) => {
+    min: number & (number | math.MathCollection<math.MathNumericType>);
+    max: number;
+};
+export declare const isMultiple: (multiple: any, src: any) => boolean | math.MathCollection<math.MathNumericType>;
+/**
+ * Accepts a fraction object {n,d,s} or number.
+ * @param {*} v
+ * @return mathjs.fraction
+ */
+export declare const fraction: (v: any) => math.Fraction | undefined;
+export declare const normalizeTicks: (domain: any, width: any, ticks: any, opts: any) => {
+    major: any;
+    minor: any;
+};
+/**
+ * Build ticks as an array of mathjs Fractions
+ */
+export declare const buildTickDataAsFractions: (domain: any, width: any, ticks: any, opts: any) => {
+    x: string | math.MathType;
+    type: string;
+}[];
+export declare const generateMinorValues: (minorLimits: any) => {
+    fraction: never[];
+    decimal: never[];
+};
+export declare const generateMajorValuesForMinor: (minor: any, domain: any, width: any) => {
+    decimal: never[];
+    fraction: never[];
+};
+export declare const buildTickData: (domain: any, width: any, ticks: any, opts: any) => {
+    x: string | math.MathType;
+    type: string;
+}[];
+export declare const fractionSnapTo: (min: any, max: any, interval: any, value: any) => any;
+export declare const snapTo: (min: any, max: any, interval: any, value: any) => number;
+export declare const snapElements: (domain: any, ticks: any, elements: any) => any;

package/dist/delivery/number-line/graph/tick-utils.js

@@ -0,0 +1,295 @@
+import { __exportAll as e } from "../../../_virtual/_rolldown/runtime.js";
+import * as t from "mathjs";
+import { isNumber as n, isObject as r, uniqWith as i } from "@pie-element/shared-lodash";
+//#region src/delivery/number-line/graph/tick-utils.ts
+var a = /* @__PURE__ */ e({
+	buildTickData: () => w,
+	buildTickDataAsFractions: () => x,
+	closeTo: () => h,
+	decimalTickValues: () => o,
+	fraction: () => y,
+	fractionRange: () => l,
+	fractionSnapTo: () => T,
+	fractionTickValues: () => s,
+	generateMajorValuesForMinor: () => C,
+	generateMinorValues: () => S,
+	getMinorLimits: () => _,
+	isMultiple: () => v,
+	labelMultiplier: () => c,
+	normalizeTicks: () => b,
+	simpleRange: () => m,
+	snapElements: () => D,
+	snapTo: () => E,
+	zbrErrorMessage: () => u,
+	zeroBasedRange: () => d
+}), o = [
+	.001,
+	.01,
+	.02,
+	.04,
+	.05,
+	.1,
+	.125,
+	.2,
+	.25,
+	.5
+], s = [
+	"1/1000",
+	"1/100",
+	"1/64",
+	"1/50",
+	"1/32",
+	"1/25",
+	"1/20",
+	"1/16",
+	"1/15",
+	"1/12",
+	"1/10",
+	"1/9",
+	"1/8",
+	"1/7",
+	"1/6",
+	"1/5",
+	"1/4",
+	"1/3",
+	"1/2"
+], c = {
+	1: [
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		9,
+		10
+	],
+	2: [
+		1,
+		2,
+		4,
+		6,
+		8,
+		10
+	],
+	3: [
+		1,
+		3,
+		6,
+		9
+	],
+	4: [
+		1,
+		2,
+		4,
+		8
+	],
+	5: [
+		1,
+		5,
+		10
+	],
+	6: [
+		1,
+		2,
+		3,
+		6
+	],
+	7: [1, 7],
+	8: [
+		1,
+		2,
+		4,
+		8
+	],
+	9: [
+		1,
+		3,
+		9
+	],
+	10: [
+		1,
+		2,
+		5,
+		10
+	],
+	12: [
+		1,
+		2,
+		3,
+		4,
+		6
+	],
+	15: [
+		1,
+		3,
+		5
+	],
+	16: [
+		1,
+		2,
+		4,
+		8
+	],
+	20: [
+		1,
+		2,
+		4,
+		5,
+		10
+	],
+	25: [1, 5],
+	32: [
+		1,
+		2,
+		4,
+		8
+	],
+	50: [
+		1,
+		2,
+		5,
+		10
+	],
+	64: [
+		1,
+		2,
+		4,
+		8
+	],
+	100: [
+		1,
+		2,
+		4,
+		5,
+		10
+	],
+	1e3: [
+		1,
+		2,
+		4,
+		5,
+		8,
+		10
+	]
+}, l = (e, n, r) => {
+	let i = t.mod(t.abs(e), t.abs(r));
+	if (!t.equal(i, 0)) throw Error("start point must be divisible by interval");
+	if (t.equal(e, n)) return [];
+	let a = t.subtract(n, t.mod(n, t.abs(r))), o = t.larger(r, 0) ? "positive" : "negative";
+	if (o === "negative" && t.largerEq(n, e)) throw Error("start must be > than end when doing a negative decrement");
+	if (o === "positive" && t.smallerEq(n, e)) throw Error("start must be < end when doing increments");
+	let s;
+	s = o === "positive" ? t.smallerEq : t.equal(a, n) ? t.largerEq : t.larger;
+	let c = [], l = e;
+	for (; s(l, a);) c.push(l), l = t.add(l, r);
+	return c;
+}, u = (e, t) => `Can only do a positive or negative range, but got: start: ${e} and end:${t}`, d = (e, n, r) => {
+	e = t.fraction(e), n = t.fraction(n), r = t.fraction(r);
+	let i = t.abs(t.subtract(n, e));
+	if (t.larger(i, t.abs(n))) throw Error(u(e, n));
+	let a = {
+		start: t.abs(e),
+		end: t.abs(n),
+		interval: t.abs(r),
+		multiplier: t.smaller(r, 0) ? -1 : 1
+	}, o = t.mod(a.start, a.interval), s = l(t.larger(o, 0) ? t.add(t.subtract(a.start, o), a.interval) : a.start, a.end, a.interval), c = a.multiplier === -1 ? s.map((e) => t.multiply(e, -1)) : s;
+	return t.smaller(r, 0) && c.reverse(), c;
+}, f = (e, n) => (e = t.fraction(e), n = t.fraction(n), t.smaller(e, n) ? e : n), p = (e, n) => (e = t.fraction(e), n = t.fraction(n), t.larger(e, n) ? e : n), m = (e, n, r) => {
+	e = t.fraction(e), n = t.fraction(n), r = t.fraction(r);
+	let a = t.larger(n, 0) ? d(p(0, e), n, r) : [];
+	return i((t.smaller(e, 0) ? d(f(0, n), e, t.multiply(r, -1)) : []).concat(a), t.equal);
+}, h = (e, t, n) => {
+	n ||= 2;
+	let r = 10 ** -n / 2;
+	return Math.abs(e - t) < r;
+}, g = (e, n, r) => t.smaller(y(e), y(n)) ? n : t.larger(y(e), y(r)) ? r : e, _ = (e, n) => {
+	let r = e.max - e.min, i = t.number(t.multiply(10, t.divide(t.fraction(r), n)));
+	return {
+		min: i,
+		max: t.number(t.multiply(20, i))
+	};
+}, v = (e, n) => {
+	let r = t.mod(e, n);
+	return t.equal(r, 0);
+}, y = (e) => {
+	if (r(e)) return t.fraction(e.n * e.s, e.d);
+	if (n(e)) return t.fraction(e);
+}, b = (e, n, r, i) => {
+	let a = i ? i.limit !== !1 : !0, o = _(e, n), s = a ? g(y(r.minor), o.min, o.max) : y(r.minor), c = a ? g(y(r.major), s, t.multiply(s, 20)) : y(r.major);
+	if (!v(c, s)) {
+		let e = t.divide(c, s), n = e <= 2 ? 2 : Math.round(e);
+		return {
+			minor: s,
+			major: t.multiply(s, n)
+		};
+	}
+	return {
+		major: c,
+		minor: s
+	};
+}, x = (e, n, r, i) => (r = b(e, n, r, i), m(e.min, e.max, r.minor).filter((n) => t.smallerEq(n, t.fraction(e.max))).map((e) => {
+	let n = "minor", i = t.mod(e, r.major);
+	return h(t.number(i), 0) && (n = "major"), {
+		x: e,
+		type: n
+	};
+})), S = (e) => {
+	let n = {
+		fraction: [],
+		decimal: []
+	};
+	return o.forEach((t) => {
+		t >= e.min && t <= e.max && n.decimal.push(t);
+	}), s.forEach((r) => {
+		let i = t.number(t.fraction(r));
+		i >= e.min && i <= e.max && n.fraction.push(r);
+	}), n;
+}, C = (e, n, r) => {
+	let i = {
+		decimal: [],
+		fraction: []
+	}, a = t.fraction(t.number(t.number(e))), o = a.n, s = a.d;
+	if (o >= 1 && s === 1) for (let a = 1; a <= 10; a++) {
+		let s = t.number(t.multiply(o, a));
+		w(n, r, {
+			minor: e,
+			major: s
+		}, { fraction: void 0 }).filter((e) => e.type === "major").length > 1 && (i.fraction.push(s.toString()), i.decimal.push(s));
+	}
+	else for (let a in c[s]) {
+		let l = t.multiply(t.fraction(o, s), c[s][a]);
+		w(n, r, {
+			minor: e,
+			major: t.number(l)
+		}, { fraction: void 0 }).filter((e) => e.type === "major").length > 1 && (l.d === 1 ? i.fraction.push(l.n.toString()) : i.fraction.push(l.n + "/" + l.d), i.decimal.push(t.number(l)));
+	}
+	return i;
+}, w = (e, n, r, i) => x(e, n, r, i).map((e) => i.fraction ? e : {
+	...e,
+	x: t.number(e.x) || 0
+}), T = (e, n, r, i) => {
+	i = p(f(i, n), e);
+	let a = i.mod(r), o, s = r.div(2);
+	if (t.largerEq(t.abs(a), s)) {
+		let e = r.sub(t.abs(a)), n = t.largerEq(i, 0) ? "add" : "sub";
+		o = i[n](e);
+	} else {
+		let e = t.largerEq(i, 0) ? "sub" : "add";
+		o = i[e](t.abs(a));
+	}
+	return o;
+}, E = (e, n, r, i) => {
+	let a = T(t.fraction(e), t.fraction(n), t.fraction(r), t.fraction(i));
+	return t.number(a);
+}, D = (e, t, n) => n.map((n) => {
+	let r = Number.isFinite(n.size) ? E(0, n.size, t.minor, n.size) : void 0, i = E(e.min, e.max, t.minor, n.domainPosition), a = {
+		...n,
+		domainPosition: i
+	};
+	return Number.isFinite(r) && (a.size = r), a;
+});
+//#endregion
+export { w as buildTickData, C as generateMajorValuesForMinor, S as generateMinorValues, _ as getMinorLimits, D as snapElements, E as snapTo, a as tick_utils_exports };