@ryuzaki13/react-foundation-lib 2.9.0 → 2.10.0

package/README.md

@@ -111,6 +111,7 @@ npm run pack:dry-run
 | `/crypto`              | [`crypto/README.mdx`](./src/crypto/README.mdx)                                 |
 | `/currency`            | [`currency/README.mdx`](./src/currency/README.mdx)                             |
 | `/date-segments`       | [`date-segments/README.mdx`](./src/date-segments/README.mdx)                   |
+| `/decimal`             | [Точная десятичная арифметика](./src/decimal/README.md)                        |
 | `/dom`                 | [`dom/README.mdx`](./src/dom/README.mdx)                                       |
 | `/error`               | [`error/README.mdx`](./src/error/README.mdx)                                   |
 | `/error-report`        | [`error-report/README.mdx`](./src/error-report/README.mdx)                     |

package/dist/decimal/addDecimals.d.ts

@@ -0,0 +1,4 @@
+import type { DecimalOptions } from "./types";
+/** Складывает значения без IEEE 754 и возвращает каноническую строку. */
+export declare function addDecimals(left: string, right: string, options?: DecimalOptions): string;
+//# sourceMappingURL=addDecimals.d.ts.map

package/dist/decimal/addDecimals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addDecimals.d.ts","sourceRoot":"","sources":["../../src/decimal/addDecimals.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAIzF"}

package/dist/decimal/alignDecimalParts.d.ts

@@ -0,0 +1,8 @@
+import type { DecimalParts } from "./types";
+/** Выравнивает только разрядность ограниченных операндов; глобального кеша степеней нет. */
+export declare function alignDecimalParts(left: DecimalParts, right: DecimalParts): Readonly<{
+    left: bigint;
+    right: bigint;
+    scale: number;
+}>;
+//# sourceMappingURL=alignDecimalParts.d.ts.map

package/dist/decimal/alignDecimalParts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alignDecimalParts.d.ts","sourceRoot":"","sources":["../../src/decimal/alignDecimalParts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,4FAA4F;AAC5F,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,QAAQ,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAQnI"}

package/dist/decimal/compareDecimalRatios.d.ts

@@ -0,0 +1,4 @@
+import type { DecimalComparison, DecimalOptions, DecimalRatio } from "./types";
+/** Сравнивает отношения перекрёстным умножением. Периодическая дробь не делится и не округляется. */
+export declare function compareDecimalRatios(left: DecimalRatio, right: DecimalRatio, options?: DecimalOptions): DecimalComparison;
+//# sourceMappingURL=compareDecimalRatios.d.ts.map

package/dist/decimal/compareDecimalRatios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareDecimalRatios.d.ts","sourceRoot":"","sources":["../../src/decimal/compareDecimalRatios.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE/E,qGAAqG;AACrG,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,iBAAiB,CAkBzH"}

package/dist/decimal/compareDecimals.d.ts

@@ -0,0 +1,4 @@
+import type { DecimalComparison, DecimalOptions } from "./types";
+/** Сравнивает исходные значения, включая разрядность за пределами безопасного number. */
+export declare function compareDecimals(left: string, right: string, options?: DecimalOptions): DecimalComparison;
+//# sourceMappingURL=compareDecimals.d.ts.map

package/dist/decimal/compareDecimals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareDecimals.d.ts","sourceRoot":"","sources":["../../src/decimal/compareDecimals.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEjE,yFAAyF;AACzF,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,iBAAiB,CAIxG"}

package/dist/decimal/index.d.ts

@@ -0,0 +1,10 @@
+export { addDecimals } from "./addDecimals";
+export { compareDecimalRatios } from "./compareDecimalRatios";
+export { compareDecimals } from "./compareDecimals";
+export { isCanonicalDecimal } from "./isCanonicalDecimal";
+export { multiplyDecimals } from "./multiplyDecimals";
+export { normalizeDecimal } from "./normalizeDecimal";
+export { subtractDecimals } from "./subtractDecimals";
+export { sumDecimals } from "./sumDecimals";
+export type { DecimalComparison, DecimalOptions, DecimalRatio } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/decimal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decimal/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC"}

package/dist/decimal/index.js

@@ -0,0 +1,108 @@
+//#region src/decimal/alignDecimalParts.ts
+function e(e, t) {
+	let n = Math.max(e.scale, t.scale);
+	return {
+		left: e.coefficient * 10n ** BigInt(n - e.scale),
+		right: t.coefficient * 10n ** BigInt(n - t.scale),
+		scale: n
+	};
+}
+//#endregion
+//#region src/decimal/resolveDecimalMaxLength.ts
+function t(e) {
+	let t = e?.maxLength ?? 512;
+	if (!Number.isSafeInteger(t) || t <= 0) throw RangeError("Предел длины десятичного значения должен быть положительным безопасным целым числом.");
+	return t;
+}
+//#endregion
+//#region src/decimal/isCanonicalDecimal.ts
+function n(e, n) {
+	let r = t(n);
+	return typeof e == "string" && e.length <= r && /^(?:0|-?(?:[1-9]\d*(?:\.\d*[1-9])?|0\.\d*[1-9]))(?![\s\S])/u.test(e);
+}
+//#endregion
+//#region src/decimal/readDecimalParts.ts
+function r(e, t) {
+	if (!n(e, t)) throw TypeError("Ожидалась каноническая десятичная строка в пределах допустимой длины.");
+	let r = e.indexOf(".");
+	return {
+		coefficient: BigInt(e.replace(".", "")),
+		scale: r === -1 ? 0 : e.length - r - 1
+	};
+}
+//#endregion
+//#region src/decimal/writeDecimalParts.ts
+function i(e, n) {
+	let r = t(n);
+	if (e.coefficient === 0n) return "0";
+	let i = e.coefficient < 0n, a = (i ? -e.coefficient : e.coefficient).toString().padStart(e.scale + 1, "0"), o = a.length - e.scale, s = e.scale === 0 ? a : `${a.slice(0, o)}.${a.slice(o)}`.replace(/\.?0+$/u, ""), c = i ? `-${s}` : s;
+	if (c.length > r) throw RangeError("Результат десятичного вычисления превысил допустимую длину.");
+	return c;
+}
+//#endregion
+//#region src/decimal/addDecimals.ts
+function a(t, n, a) {
+	let o = e(r(t, a), r(n, a));
+	return i({
+		coefficient: o.left + o.right,
+		scale: o.scale
+	}, a);
+}
+//#endregion
+//#region src/decimal/compareDecimalRatios.ts
+function o(t, n, i) {
+	let a = r(t.numerator, i), o = r(t.denominator, i), s = r(n.numerator, i), c = r(n.denominator, i);
+	if (o.coefficient <= 0n || c.coefficient <= 0n) throw RangeError("Знаменатель отношения должен быть строго положительным.");
+	let l = e({
+		coefficient: a.coefficient * c.coefficient,
+		scale: a.scale + c.scale
+	}, {
+		coefficient: s.coefficient * o.coefficient,
+		scale: s.scale + o.scale
+	});
+	return l.left < l.right ? -1 : +(l.left > l.right);
+}
+//#endregion
+//#region src/decimal/compareDecimals.ts
+function s(t, n, i) {
+	let a = e(r(t, i), r(n, i));
+	return a.left < a.right ? -1 : +(a.left > a.right);
+}
+//#endregion
+//#region src/decimal/multiplyDecimals.ts
+function c(e, t, n) {
+	let a = r(e, n), o = r(t, n);
+	return i({
+		coefficient: a.coefficient * o.coefficient,
+		scale: a.scale + o.scale
+	}, n);
+}
+//#endregion
+//#region src/decimal/normalizeDecimal.ts
+function l(e, n) {
+	let r = t(n);
+	if (typeof e != "string" || e.length > r || !/^-?\d+(?:\.\d+)?(?![\s\S])/u.test(e)) throw TypeError("Ожидалась ограниченная конечная десятичная строка с точкой.");
+	let i = e.startsWith("-"), [a, o = ""] = (i ? e.slice(1) : e).split("."), s = a.replace(/^0+(?=\d)/u, ""), c = o.replace(/0+$/u, ""), l = c ? `${s}.${c}` : s;
+	return i && l !== "0" ? `-${l}` : l;
+}
+//#endregion
+//#region src/decimal/subtractDecimals.ts
+function u(t, n, a) {
+	let o = e(r(t, a), r(n, a));
+	return i({
+		coefficient: o.left - o.right,
+		scale: o.scale
+	}, a);
+}
+//#endregion
+//#region src/decimal/sumDecimals.ts
+function d(e, n) {
+	t(n);
+	let r = "0";
+	for (let t of e) r = a(r, t, n);
+	return r;
+}
+//#endregion
+export { a as addDecimals, o as compareDecimalRatios, s as compareDecimals, n as isCanonicalDecimal, c as multiplyDecimals, l as normalizeDecimal, u as subtractDecimals, d as sumDecimals };
+
+//# sourceMappingURL=index.js.map

package/dist/decimal/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/decimal/alignDecimalParts.ts","../../src/decimal/resolveDecimalMaxLength.ts","../../src/decimal/isCanonicalDecimal.ts","../../src/decimal/readDecimalParts.ts","../../src/decimal/writeDecimalParts.ts","../../src/decimal/addDecimals.ts","../../src/decimal/compareDecimalRatios.ts","../../src/decimal/compareDecimals.ts","../../src/decimal/multiplyDecimals.ts","../../src/decimal/normalizeDecimal.ts","../../src/decimal/subtractDecimals.ts","../../src/decimal/sumDecimals.ts"],"sourcesContent":["import type { DecimalParts } from \"./types\";\n\n/** Выравнивает только разрядность ограниченных операндов; глобального кеша степеней нет. */\nexport function alignDecimalParts(left: DecimalParts, right: DecimalParts): Readonly<{ left: bigint; right: bigint; scale: number }> {\n\tconst scale = Math.max(left.scale, right.scale);\n\n\treturn {\n\t\tleft: left.coefficient * 10n ** BigInt(scale - left.scale),\n\t\tright: right.coefficient * 10n ** BigInt(scale - right.scale),\n\t\tscale\n\t};\n}\n","import type { DecimalOptions } from \"./types\";\n\n/** Проверяет предел до разбора числа и выделения вычислительных буферов. */\nexport function resolveDecimalMaxLength(options?: DecimalOptions): number {\n\tconst maxLength = options?.maxLength ?? 512;\n\n\tif (!Number.isSafeInteger(maxLength) || maxLength <= 0) {\n\t\tthrow new RangeError(\"Предел длины десятичного значения должен быть положительным безопасным целым числом.\");\n\t}\n\n\treturn maxLength;\n}\n","import { resolveDecimalMaxLength } from \"./resolveDecimalMaxLength\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Runtime-проверка для внешних данных без преобразования значащих цифр в number. */\nexport function isCanonicalDecimal(value: unknown, options?: DecimalOptions): value is string {\n\tconst maxLength = resolveDecimalMaxLength(options);\n\n\treturn (\n\t\ttypeof value === \"string\" && value.length <= maxLength && /^(?:0|-?(?:[1-9]\\d*(?:\\.\\d*[1-9])?|0\\.\\d*[1-9]))(?![\\s\\S])/u.test(value)\n\t);\n}\n","import { isCanonicalDecimal } from \"./isCanonicalDecimal\";\n\nimport type { DecimalOptions, DecimalParts } from \"./types\";\n\n/** Арифметика принимает только канонические строки; нормализация принадлежит входной границе. */\nexport function readDecimalParts(value: string, options?: DecimalOptions): DecimalParts {\n\tif (!isCanonicalDecimal(value, options)) {\n\t\tthrow new TypeError(\"Ожидалась каноническая десятичная строка в пределах допустимой длины.\");\n\t}\n\n\tconst point = value.indexOf(\".\");\n\n\treturn {\n\t\tcoefficient: BigInt(value.replace(\".\", \"\")),\n\t\tscale: point === -1 ? 0 : value.length - point - 1\n\t};\n}\n","import { resolveDecimalMaxLength } from \"./resolveDecimalMaxLength\";\n\nimport type { DecimalOptions, DecimalParts } from \"./types\";\n\n/** Канонизирует результат после точного вычисления и отклоняет overflow вместо округления. */\nexport function writeDecimalParts(parts: DecimalParts, options?: DecimalOptions): string {\n\tconst maxLength = resolveDecimalMaxLength(options);\n\n\tif (parts.coefficient === 0n) {\n\t\treturn \"0\";\n\t}\n\n\tconst negative = parts.coefficient < 0n;\n\tconst magnitude = negative ? -parts.coefficient : parts.coefficient;\n\tconst digits = magnitude.toString().padStart(parts.scale + 1, \"0\");\n\tconst point = digits.length - parts.scale;\n\tconst unsigned = parts.scale === 0 ? digits : `${digits.slice(0, point)}.${digits.slice(point)}`.replace(/\\.?0+$/u, \"\");\n\tconst result = negative ? `-${unsigned}` : unsigned;\n\n\tif (result.length > maxLength) {\n\t\tthrow new RangeError(\"Результат десятичного вычисления превысил допустимую длину.\");\n\t}\n\n\treturn result;\n}\n","import { alignDecimalParts } from \"./alignDecimalParts\";\nimport { readDecimalParts } from \"./readDecimalParts\";\nimport { writeDecimalParts } from \"./writeDecimalParts\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Складывает значения без IEEE 754 и возвращает каноническую строку. */\nexport function addDecimals(left: string, right: string, options?: DecimalOptions): string {\n\tconst aligned = alignDecimalParts(readDecimalParts(left, options), readDecimalParts(right, options));\n\n\treturn writeDecimalParts({ coefficient: aligned.left + aligned.right, scale: aligned.scale }, options);\n}\n","import { alignDecimalParts } from \"./alignDecimalParts\";\nimport { readDecimalParts } from \"./readDecimalParts\";\n\nimport type { DecimalComparison, DecimalOptions, DecimalRatio } from \"./types\";\n\n/** Сравнивает отношения перекрёстным умножением. Периодическая дробь не делится и не округляется. */\nexport function compareDecimalRatios(left: DecimalRatio, right: DecimalRatio, options?: DecimalOptions): DecimalComparison {\n\tconst leftNumerator = readDecimalParts(left.numerator, options);\n\tconst leftDenominator = readDecimalParts(left.denominator, options);\n\tconst rightNumerator = readDecimalParts(right.numerator, options);\n\tconst rightDenominator = readDecimalParts(right.denominator, options);\n\n\tif (leftDenominator.coefficient <= 0n || rightDenominator.coefficient <= 0n) {\n\t\tthrow new RangeError(\"Знаменатель отношения должен быть строго положительным.\");\n\t}\n\n\t// Произведения приватные: их разрядность ограничена четырьмя проверенными операндами,\n\t// но может превышать длину сериализуемого числа. Проверять их как внешний результат нельзя.\n\tconst aligned = alignDecimalParts(\n\t\t{ coefficient: leftNumerator.coefficient * rightDenominator.coefficient, scale: leftNumerator.scale + rightDenominator.scale },\n\t\t{ coefficient: rightNumerator.coefficient * leftDenominator.coefficient, scale: rightNumerator.scale + leftDenominator.scale }\n\t);\n\n\treturn aligned.left < aligned.right ? -1 : aligned.left > aligned.right ? 1 : 0;\n}\n","import { alignDecimalParts } from \"./alignDecimalParts\";\nimport { readDecimalParts } from \"./readDecimalParts\";\n\nimport type { DecimalComparison, DecimalOptions } from \"./types\";\n\n/** Сравнивает исходные значения, включая разрядность за пределами безопасного number. */\nexport function compareDecimals(left: string, right: string, options?: DecimalOptions): DecimalComparison {\n\tconst aligned = alignDecimalParts(readDecimalParts(left, options), readDecimalParts(right, options));\n\n\treturn aligned.left < aligned.right ? -1 : aligned.left > aligned.right ? 1 : 0;\n}\n","import { readDecimalParts } from \"./readDecimalParts\";\nimport { writeDecimalParts } from \"./writeDecimalParts\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Точное умножение не устанавливает фиксированную сетку дробности. */\nexport function multiplyDecimals(left: string, right: string, options?: DecimalOptions): string {\n\tconst first = readDecimalParts(left, options);\n\tconst second = readDecimalParts(right, options);\n\n\treturn writeDecimalParts({ coefficient: first.coefficient * second.coefficient, scale: first.scale + second.scale }, options);\n}\n","import { resolveDecimalMaxLength } from \"./resolveDecimalMaxLength\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Убирает лишние нули. Пробелы, запятую, плюс и экспоненту обрабатывает владелец внешнего формата. */\nexport function normalizeDecimal(value: string, options?: DecimalOptions): string {\n\tconst maxLength = resolveDecimalMaxLength(options);\n\n\tif (typeof value !== \"string\" || value.length > maxLength || !/^-?\\d+(?:\\.\\d+)?(?![\\s\\S])/u.test(value)) {\n\t\tthrow new TypeError(\"Ожидалась ограниченная конечная десятичная строка с точкой.\");\n\t}\n\n\tconst negative = value.startsWith(\"-\");\n\tconst unsigned = negative ? value.slice(1) : value;\n\tconst [integer, fraction = \"\"] = unsigned.split(\".\");\n\tconst whole = integer.replace(/^0+(?=\\d)/u, \"\");\n\tconst fractional = fraction.replace(/0+$/u, \"\");\n\tconst magnitude = fractional ? `${whole}.${fractional}` : whole;\n\n\treturn negative && magnitude !== \"0\" ? `-${magnitude}` : magnitude;\n}\n","import { alignDecimalParts } from \"./alignDecimalParts\";\nimport { readDecimalParts } from \"./readDecimalParts\";\nimport { writeDecimalParts } from \"./writeDecimalParts\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Сохраняет знак остатка; предметные ограничения отрицательных значений находятся у consumer. */\nexport function subtractDecimals(left: string, right: string, options?: DecimalOptions): string {\n\tconst aligned = alignDecimalParts(readDecimalParts(left, options), readDecimalParts(right, options));\n\n\treturn writeDecimalParts({ coefficient: aligned.left - aligned.right, scale: aligned.scale }, options);\n}\n","import { addDecimals } from \"./addDecimals\";\nimport { resolveDecimalMaxLength } from \"./resolveDecimalMaxLength\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Читает iterable один раз и проверяет каждый промежуточный итог; пустой набор даёт ноль. */\nexport function sumDecimals(values: Iterable<string>, options?: DecimalOptions): string {\n\tresolveDecimalMaxLength(options);\n\tlet total = \"0\";\n\n\tfor (const value of values) {\n\t\ttotal = addDecimals(total, value, options);\n\t}\n\n\treturn total;\n}\n"],"mappings":"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"}

package/dist/decimal/isCanonicalDecimal.d.ts

@@ -0,0 +1,4 @@
+import type { DecimalOptions } from "./types";
+/** Runtime-проверка для внешних данных без преобразования значащих цифр в number. */
+export declare function isCanonicalDecimal(value: unknown, options?: DecimalOptions): value is string;
+//# sourceMappingURL=isCanonicalDecimal.d.ts.map

package/dist/decimal/isCanonicalDecimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isCanonicalDecimal.d.ts","sourceRoot":"","sources":["../../src/decimal/isCanonicalDecimal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,qFAAqF;AACrF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,KAAK,IAAI,MAAM,CAM5F"}

package/dist/decimal/multiplyDecimals.d.ts

@@ -0,0 +1,4 @@
+import type { DecimalOptions } from "./types";
+/** Точное умножение не устанавливает фиксированную сетку дробности. */
+export declare function multiplyDecimals(left: string, right: string, options?: DecimalOptions): string;
+//# sourceMappingURL=multiplyDecimals.d.ts.map

package/dist/decimal/multiplyDecimals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiplyDecimals.d.ts","sourceRoot":"","sources":["../../src/decimal/multiplyDecimals.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,uEAAuE;AACvE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAK9F"}

package/dist/decimal/normalizeDecimal.d.ts

@@ -0,0 +1,4 @@
+import type { DecimalOptions } from "./types";
+/** Убирает лишние нули. Пробелы, запятую, плюс и экспоненту обрабатывает владелец внешнего формата. */
+export declare function normalizeDecimal(value: string, options?: DecimalOptions): string;
+//# sourceMappingURL=normalizeDecimal.d.ts.map

package/dist/decimal/normalizeDecimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeDecimal.d.ts","sourceRoot":"","sources":["../../src/decimal/normalizeDecimal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,uGAAuG;AACvG,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAehF"}

package/dist/decimal/readDecimalParts.d.ts

@@ -0,0 +1,4 @@
+import type { DecimalOptions, DecimalParts } from "./types";
+/** Арифметика принимает только канонические строки; нормализация принадлежит входной границе. */
+export declare function readDecimalParts(value: string, options?: DecimalOptions): DecimalParts;
+//# sourceMappingURL=readDecimalParts.d.ts.map

package/dist/decimal/readDecimalParts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readDecimalParts.d.ts","sourceRoot":"","sources":["../../src/decimal/readDecimalParts.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5D,iGAAiG;AACjG,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,YAAY,CAWtF"}

package/dist/decimal/resolveDecimalMaxLength.d.ts

@@ -0,0 +1,4 @@
+import type { DecimalOptions } from "./types";
+/** Проверяет предел до разбора числа и выделения вычислительных буферов. */
+export declare function resolveDecimalMaxLength(options?: DecimalOptions): number;
+//# sourceMappingURL=resolveDecimalMaxLength.d.ts.map

package/dist/decimal/resolveDecimalMaxLength.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveDecimalMaxLength.d.ts","sourceRoot":"","sources":["../../src/decimal/resolveDecimalMaxLength.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,4EAA4E;AAC5E,wBAAgB,uBAAuB,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAQxE"}

package/dist/decimal/subtractDecimals.d.ts

@@ -0,0 +1,4 @@
+import type { DecimalOptions } from "./types";
+/** Сохраняет знак остатка; предметные ограничения отрицательных значений находятся у consumer. */
+export declare function subtractDecimals(left: string, right: string, options?: DecimalOptions): string;
+//# sourceMappingURL=subtractDecimals.d.ts.map

package/dist/decimal/subtractDecimals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtractDecimals.d.ts","sourceRoot":"","sources":["../../src/decimal/subtractDecimals.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,kGAAkG;AAClG,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAI9F"}

package/dist/decimal/sumDecimals.d.ts

@@ -0,0 +1,4 @@
+import type { DecimalOptions } from "./types";
+/** Читает iterable один раз и проверяет каждый промежуточный итог; пустой набор даёт ноль. */
+export declare function sumDecimals(values: Iterable<string>, options?: DecimalOptions): string;
+//# sourceMappingURL=sumDecimals.d.ts.map

package/dist/decimal/sumDecimals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sumDecimals.d.ts","sourceRoot":"","sources":["../../src/decimal/sumDecimals.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,8FAA8F;AAC9F,wBAAgB,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAStF"}

package/dist/decimal/types.d.ts

@@ -0,0 +1,16 @@
+/** Лимит относится к строке целиком, включая знак и точку; точность не округляется. */
+export type DecimalOptions = Readonly<{
+    maxLength?: number;
+}>;
+export type DecimalComparison = -1 | 0 | 1;
+/** Отношение сохраняется без деления: знаменатель должен быть строго положительным. */
+export type DecimalRatio = Readonly<{
+    numerator: string;
+    denominator: string;
+}>;
+/** Приватное вычислительное представление, не входящее в публичный entrypoint. */
+export type DecimalParts = Readonly<{
+    coefficient: bigint;
+    scale: number;
+}>;
+//# sourceMappingURL=types.d.ts.map

package/dist/decimal/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/decimal/types.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAE9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE3C,uFAAuF;AACvF,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEhF,kFAAkF;AAClF,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC"}

package/dist/decimal/writeDecimalParts.d.ts

@@ -0,0 +1,4 @@
+import type { DecimalOptions, DecimalParts } from "./types";
+/** Канонизирует результат после точного вычисления и отклоняет overflow вместо округления. */
+export declare function writeDecimalParts(parts: DecimalParts, options?: DecimalOptions): string;
+//# sourceMappingURL=writeDecimalParts.d.ts.map

package/dist/decimal/writeDecimalParts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeDecimalParts.d.ts","sourceRoot":"","sources":["../../src/decimal/writeDecimalParts.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5D,8FAA8F;AAC9F,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAmBvF"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ryuzaki13/react-foundation-lib",
-	"version": "2.9.0",
+	"version": "2.10.0",
 	"description": "Reusable React and TypeScript foundation utilities, hooks, and primitives.",
 	"license": "MIT",
 	"author": "Ryuzaki13",
@@ -61,6 +61,10 @@
 			"types": "./dist/date-segments/index.d.ts",
 			"import": "./dist/date-segments/index.js"
 		},
+		"./decimal": {
+			"types": "./dist/decimal/index.d.ts",
+			"import": "./dist/decimal/index.js"
+		},
 		"./dom": {
 			"types": "./dist/dom/index.d.ts",
 			"import": "./dist/dom/index.js"

package/src/decimal/README.md

@@ -0,0 +1,43 @@
+# Точные десятичные значения
+
+Публичный импорт: `@ryuzaki13/react-foundation-lib/decimal`.
+Модуль вычисляет конечные десятичные значения как целый коэффициент и число
+десятичных разрядов. Строки не переводятся в `number`; округления нет.
+React, browser API и дополнительные зависимости не требуются.
+
+```ts
+import { addDecimals, compareDecimalRatios } from "@ryuzaki13/react-foundation-lib/decimal";
+
+addDecimals("0.1", "0.2"); // "0.3"
+compareDecimalRatios({ numerator: "10", denominator: "3" }, { numerator: "3.33", denominator: "1" }); // 1
+```
+
+| API                                                   | Назначение                                                            |
+| ----------------------------------------------------- | --------------------------------------------------------------------- |
+| `isCanonicalDecimal(unknown, options?)`               | Проверить внешнее значение без преобразования                         |
+| `normalizeDecimal(string, options?)`                  | Убрать начальные и конечные нули; привести отрицательный ноль к `"0"` |
+| `addDecimals`, `subtractDecimals`, `multiplyDecimals` | Получить точный канонический результат двух операндов                 |
+| `sumDecimals(iterable, options?)`                     | Суммировать за один проход; пустой набор даёт `"0"`                   |
+| `compareDecimals`                                     | Вернуть `-1`, `0` или `1`                                             |
+| `compareDecimalRatios`                                | Сравнить отношения без деления; знаменатели строго положительные      |
+
+Каноническая строка содержит знак минус при необходимости, цифры и точку:
+`"0"`, `"0.3"`, `"-12.05"`. Пробелы, плюс, экспонента, запятая, начальные
+нули и конечные нули дробной части в арифметике отклоняются. Нормализация
+допускает только лишние нули; обработка локализованного ввода и внешних JSON
+чисел принадлежит соответствующей входной границе.
+
+`DecimalOptions.maxLength` задаёт положительный безопасный целый предел длины
+входа и результата, включая знак и точку; по умолчанию — 512 символов.
+Вход отклоняется до создания `bigint` и выравнивания разрядов. Неверная форма
+даёт `TypeError`, неверный предел, overflow результата и недопустимый знаменатель
+— `RangeError`. `isCanonicalDecimal` возвращает `false` для неверного значения,
+но неверная конфигурация предела также даёт `RangeError`.
+
+Суммирование проверяет каждый промежуточный результат: даже последующее
+взаимное сокращение не отменяет уже возникшее переполнение. При сравнении
+отношений произведения не сериализуются; они могут превышать предел строки,
+оставаясь ограниченными длиной проверенных операндов.
+
+Предметные правила положительности, единиц измерения и допустимости нуля
+остаются у приложения. Приватные коэффициенты и разрядность не входят в API.