@pksep/zod-shared 0.0.548 → 0.0.550

package/dist/material/utils/workpiece-mass.d.ts

@@ -0,0 +1,56 @@
+import { WorkpieceMassFormulaKey } from '../enum/enum';
+import type { ModelMaterial } from '../schemas/material.schema';
+import type { ModelTypeMaterial } from '../schemas/type-material.schema';
+export type TWorkpieceMassVariableKey = 'density' | 'length' | 'width' | 'height' | 'thickness' | 'wallThickness' | 'outsideDiameter' | 'areaCrossSectional' | 'acrossFlats' | 'massPerMeter';
+export interface IWorkpieceMassFormulaVariable {
+    key: TWorkpieceMassVariableKey;
+    name: string;
+}
+export interface IWorkpieceMassFormula {
+    key: WorkpieceMassFormulaKey;
+    name: string;
+    description: string;
+    variables: IWorkpieceMassFormulaVariable[];
+}
+export type TResolvedWorkpieceMassVariables = Partial<Record<TWorkpieceMassVariableKey, number>>;
+export interface ICalculateWorkpieceMassContext {
+    typeMaterial: ModelTypeMaterial;
+    material: ModelMaterial;
+    workpieceCharacterization?: Record<string, number | null | undefined>;
+    workpieceMassFormulaKey?: WorkpieceMassFormulaKey;
+}
+export interface ICalculateWorkpieceMassResult {
+    formulaKey: WorkpieceMassFormulaKey;
+    mass: number;
+    variables: TResolvedWorkpieceMassVariables;
+}
+export interface IDefaultTypeMaterialCharacteristic {
+    id: number;
+    name: string;
+    measure: string;
+}
+export type TDefaultTypeMaterialCharacteristicKey = Exclude<TWorkpieceMassVariableKey, 'density'>;
+export type TDefaultTypeMaterialCharacteristics = Record<TDefaultTypeMaterialCharacteristicKey, IDefaultTypeMaterialCharacteristic>;
+export interface IWorkpieceMassFormulasResponse {
+    defaultFormulas: IWorkpieceMassFormula[];
+    defaultCharacteristics: TDefaultTypeMaterialCharacteristics;
+}
+type TPreparedWorkpieceValues = Partial<Record<TWorkpieceMassVariableKey | 'mass' | 'trash', number>>;
+type TWorkpieceMassVariableResolver = (context: ICalculateWorkpieceMassContext, prepared: TPreparedWorkpieceValues) => number | null;
+type TWorkpieceMassCalculator = (vars: TResolvedWorkpieceMassVariables) => number;
+export declare const WORKPIECE_MASS_FORMULAS: IWorkpieceMassFormula[];
+export declare const WORKPIECE_MASS_VARIABLE_CHARACTERISTIC_KEYS: Record<TWorkpieceMassVariableKey, string>;
+export declare const normalizeWorkpieceMassVariables: (context: ICalculateWorkpieceMassContext, variables: TResolvedWorkpieceMassVariables, variableKeys: TWorkpieceMassVariableKey[]) => TResolvedWorkpieceMassVariables;
+/**
+ * Реестр источников значений переменных.
+ * Здесь описано, откуда брать каждую переменную под расчет массы заготовки.
+ */
+export declare const WORKPIECE_MASS_VARIABLE_RESOLVERS: Record<TWorkpieceMassVariableKey, TWorkpieceMassVariableResolver>;
+/**
+ * Реестр математических алгоритмов расчета.
+ * Здесь только математика, без поиска значений по моделям.
+ */
+export declare const WORKPIECE_MASS_CALCULATORS: Record<WorkpieceMassFormulaKey, TWorkpieceMassCalculator>;
+export declare const resolveWorkpieceMassVariables: (context: ICalculateWorkpieceMassContext, variableKeys: TWorkpieceMassVariableKey[]) => TResolvedWorkpieceMassVariables;
+export declare const calculateWorkpieceMassPreview: (context: ICalculateWorkpieceMassContext) => ICalculateWorkpieceMassResult | null;
+export {};

package/dist/material/utils/workpiece-mass.js

@@ -0,0 +1,538 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWorkpieceMassPreview = exports.resolveWorkpieceMassVariables = exports.WORKPIECE_MASS_CALCULATORS = exports.WORKPIECE_MASS_VARIABLE_RESOLVERS = exports.normalizeWorkpieceMassVariables = exports.WORKPIECE_MASS_VARIABLE_CHARACTERISTIC_KEYS = exports.WORKPIECE_MASS_FORMULAS = void 0;
+const enum_1 = require("../enum/enum");
+const utils_1 = require("../../utils");
+exports.WORKPIECE_MASS_FORMULAS = [
+    {
+        key: enum_1.WorkpieceMassFormulaKey.boundingBox,
+        name: 'Прямоугольная заготовка',
+        description: 'ρ * L * B * H',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность'
+            },
+            {
+                key: 'length',
+                name: 'Длина'
+            },
+            {
+                key: 'width',
+                name: 'Ширина'
+            },
+            {
+                key: 'height',
+                name: 'Высота'
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.rectangularSection,
+        name: 'Прямоугольное сечение',
+        description: 'ρ * L * B * t',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность'
+            },
+            {
+                key: 'length',
+                name: 'Длина'
+            },
+            {
+                key: 'width',
+                name: 'Ширина'
+            },
+            {
+                key: 'thickness',
+                name: 'Толщина'
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.solidRoundSection,
+        name: 'Полнотелое круглое сечение',
+        description: 'ρ * π * D² / 4 * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность'
+            },
+            {
+                key: 'outsideDiameter',
+                name: 'Наружный диаметр'
+            },
+            {
+                key: 'length',
+                name: 'Длина'
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.hollowRoundSection,
+        name: 'Полое круглое сечение',
+        description: 'ρ * π * t * (D - t) * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность'
+            },
+            {
+                key: 'outsideDiameter',
+                name: 'Наружный диаметр'
+            },
+            {
+                key: 'wallThickness',
+                name: 'Толщина стенки'
+            },
+            {
+                key: 'length',
+                name: 'Длина'
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.hollowProfileSection,
+        name: 'Полое профильное сечение',
+        description: 'ρ * (B * H - (B - 2t) * (H - 2t)) * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность'
+            },
+            {
+                key: 'width',
+                name: 'Ширина профиля'
+            },
+            {
+                key: 'height',
+                name: 'Высота профиля'
+            },
+            {
+                key: 'wallThickness',
+                name: 'Толщина стенки'
+            },
+            {
+                key: 'length',
+                name: 'Длина'
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.hexSection,
+        name: 'Шестигранное сечение',
+        description: 'ρ * 0.866025 * S² * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность'
+            },
+            {
+                key: 'acrossFlats',
+                name: 'Размер под ключ'
+            },
+            {
+                key: 'length',
+                name: 'Длина'
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.sectionArea,
+        name: 'По площади сечения',
+        description: 'ρ * A * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность'
+            },
+            {
+                key: 'areaCrossSectional',
+                name: 'Площадь поперечного сечения'
+            },
+            {
+                key: 'length',
+                name: 'Длина'
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.linearMass,
+        name: 'По массе погонного метра',
+        description: 'q * L',
+        variables: [
+            {
+                key: 'massPerMeter',
+                name: 'Масса погонного метра'
+            },
+            {
+                key: 'length',
+                name: 'Длина'
+            }
+        ]
+    }
+];
+const getMaterialCharacteristicValue = (context, key) => {
+    var _a, _b;
+    const item = (_b = (_a = context.material) === null || _a === void 0 ? void 0 : _a.characteristics) === null || _b === void 0 ? void 0 : _b[key];
+    return typeof (item === null || item === void 0 ? void 0 : item.znach) === 'number' && !Number.isNaN(item.znach)
+        ? item.znach
+        : null;
+};
+const getWorkpieceCharacteristicValue = (context, key) => {
+    var _a;
+    const value = (_a = context.workpieceCharacterization) === null || _a === void 0 ? void 0 : _a[key];
+    return typeof value === 'number' && !Number.isNaN(value) ? value : null;
+};
+/**
+ * Возвращаем первое осмысленное положительное значение.
+ * Это нужен совместимый fallback на переходный период,
+ * пока старый фронтенд еще может присылать permanent-поля в detail payload.
+ */
+const pickPreparedCharacteristicValue = (...values) => {
+    for (const value of values) {
+        if (typeof value === 'number' && !Number.isNaN(value) && value > 0) {
+            return value;
+        }
+    }
+    for (const value of values) {
+        if (typeof value === 'number' && !Number.isNaN(value)) {
+            return value;
+        }
+    }
+    return undefined;
+};
+const getPreparedWorkpieceValues = (context) => {
+    var _a, _b;
+    const result = {};
+    const typeMaterialCharacteristics = ((_a = context.typeMaterial) === null || _a === void 0 ? void 0 : _a.characteristics) || {};
+    for (const characteristicKey of Object.keys(typeMaterialCharacteristics)) {
+        const characteristicMode = (_b = typeMaterialCharacteristics[characteristicKey]) === null || _b === void 0 ? void 0 : _b.znach;
+        if (!characteristicMode)
+            continue;
+        result[characteristicKey] =
+            characteristicMode === utils_1.TypeMaterialCharZnachEnum.permanent
+                ? pickPreparedCharacteristicValue(getMaterialCharacteristicValue(context, characteristicKey), getWorkpieceCharacteristicValue(context, characteristicKey))
+                : pickPreparedCharacteristicValue(getWorkpieceCharacteristicValue(context, characteristicKey), getMaterialCharacteristicValue(context, characteristicKey));
+    }
+    const density = getMaterialCharacteristicValue(context, 'density');
+    if (density !== null)
+        result.density = density;
+    const mass = getWorkpieceCharacteristicValue(context, 'mass');
+    if (mass !== null)
+        result.mass = mass;
+    const trash = getWorkpieceCharacteristicValue(context, 'trash');
+    if (trash !== null)
+        result.trash = trash;
+    return result;
+};
+const getPreparedValue = (prepared, key) => {
+    const value = prepared[key];
+    return typeof value === 'number' && !Number.isNaN(value) ? value : null;
+};
+exports.WORKPIECE_MASS_VARIABLE_CHARACTERISTIC_KEYS = {
+    density: 'density',
+    length: 'length',
+    width: 'width',
+    height: 'height',
+    thickness: 'thickness',
+    wallThickness: 'wallThickness',
+    outsideDiameter: 'outsideDiameter',
+    areaCrossSectional: 'areaCrossSectional',
+    acrossFlats: 'acrossFlats',
+    massPerMeter: 'massPerMeter'
+};
+const WORKPIECE_MASS_VARIABLE_UNIT_KINDS = {
+    density: 'density',
+    length: 'length',
+    width: 'length',
+    height: 'length',
+    thickness: 'length',
+    wallThickness: 'length',
+    outsideDiameter: 'length',
+    areaCrossSectional: 'area',
+    acrossFlats: 'length',
+    massPerMeter: 'linearMass'
+};
+const normalizeUnitShortName = (shortName) => {
+    return String(shortName || '')
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, '')
+        .replace(/²/g, '2')
+        .replace(/³/g, '3')
+        .replace(/\^2/g, '2')
+        .replace(/\^3/g, '3')
+        .replace(/\.кв/g, '2')
+        .replace(/кв/g, '2')
+        .replace(/\.sq/g, '2')
+        .replace(/sq/g, '2')
+        .replace(/\.куб/g, '3')
+        .replace(/куб/g, '3')
+        .replace(/\.cub/g, '3')
+        .replace(/cub/g, '3');
+};
+const getMaterialCharacteristicUnitMeta = (context, key) => {
+    var _a, _b;
+    return (((_b = (_a = context.material) === null || _a === void 0 ? void 0 : _a.characteristics) === null || _b === void 0 ? void 0 : _b[key]) || null);
+};
+const getTypeMaterialCharacteristicUnitMeta = (context, key) => {
+    var _a, _b;
+    return (((_b = (_a = context.typeMaterial) === null || _a === void 0 ? void 0 : _a.characteristics) === null || _b === void 0 ? void 0 : _b[key]) || null);
+};
+const getVariableCharacteristicUnitMeta = (context, key) => {
+    const characteristicKey = exports.WORKPIECE_MASS_VARIABLE_CHARACTERISTIC_KEYS[key];
+    if (!characteristicKey)
+        return null;
+    if (key === 'density' || key === 'massPerMeter') {
+        return getMaterialCharacteristicUnitMeta(context, characteristicKey);
+    }
+    const typeMaterialCharacteristic = getTypeMaterialCharacteristicUnitMeta(context, characteristicKey);
+    const characteristicMode = typeMaterialCharacteristic === null || typeMaterialCharacteristic === void 0 ? void 0 : typeMaterialCharacteristic.znach;
+    if (characteristicMode === utils_1.TypeMaterialCharZnachEnum.variable) {
+        return (typeMaterialCharacteristic ||
+            getMaterialCharacteristicUnitMeta(context, characteristicKey));
+    }
+    if (characteristicMode === utils_1.TypeMaterialCharZnachEnum.permanent) {
+        return (getMaterialCharacteristicUnitMeta(context, characteristicKey) ||
+            typeMaterialCharacteristic);
+    }
+    return (getMaterialCharacteristicUnitMeta(context, characteristicKey) ||
+        typeMaterialCharacteristic);
+};
+const getUnitErrorText = (key, unit) => {
+    const unitName = (unit === null || unit === void 0 ? void 0 : unit.shortName) || (unit === null || unit === void 0 ? void 0 : unit.edizmId) || 'unknown';
+    return `Не удалось привести единицу "${unitName}" для переменной "${key}"`;
+};
+const normalizeLengthValue = (value, key, unit) => {
+    const token = normalizeUnitShortName(unit === null || unit === void 0 ? void 0 : unit.shortName);
+    if (token === 'мм' || token === 'mm' || (unit === null || unit === void 0 ? void 0 : unit.edizmId) === 6) {
+        return value / 1000;
+    }
+    if (token === 'см' || token === 'cm') {
+        return value / 100;
+    }
+    if (token === 'дм' || token === 'dm') {
+        return value / 10;
+    }
+    if (token === 'м' || token === 'm' || (unit === null || unit === void 0 ? void 0 : unit.edizmId) === 4) {
+        return value;
+    }
+    if (!token && typeof (unit === null || unit === void 0 ? void 0 : unit.edizmId) === 'undefined') {
+        return value;
+    }
+    throw new Error(getUnitErrorText(key, unit));
+};
+const normalizeAreaValue = (value, key, unit) => {
+    const token = normalizeUnitShortName(unit === null || unit === void 0 ? void 0 : unit.shortName);
+    if (token === 'мм2' || token === 'mm2') {
+        return value / 1000000;
+    }
+    if (token === 'см2' || token === 'cm2') {
+        return value / 10000;
+    }
+    if (token === 'дм2' || token === 'dm2') {
+        return value / 100;
+    }
+    if (token === 'м2' || token === 'm2' || (unit === null || unit === void 0 ? void 0 : unit.edizmId) === 8) {
+        return value;
+    }
+    if (!token && typeof (unit === null || unit === void 0 ? void 0 : unit.edizmId) === 'undefined') {
+        return value;
+    }
+    throw new Error(getUnitErrorText(key, unit));
+};
+const normalizeDensityValue = (value, key, unit) => {
+    const token = normalizeUnitShortName(unit === null || unit === void 0 ? void 0 : unit.shortName);
+    if (token === 'кг/м3' || token === 'kg/m3') {
+        return value;
+    }
+    if (token === 'г/см3' || token === 'g/cm3') {
+        return value * 1000;
+    }
+    if (token === 'т/м3' || token === 't/m3') {
+        return value * 1000;
+    }
+    if (!token && typeof (unit === null || unit === void 0 ? void 0 : unit.edizmId) === 'undefined') {
+        return value;
+    }
+    throw new Error(getUnitErrorText(key, unit));
+};
+const normalizeLinearMassValue = (value, key, unit) => {
+    const token = normalizeUnitShortName(unit === null || unit === void 0 ? void 0 : unit.shortName);
+    if (token === 'кг/м' || token === 'kg/m') {
+        return value;
+    }
+    if (token === 'г/м' || token === 'g/m') {
+        return value / 1000;
+    }
+    if (token === 'г/мм' || token === 'g/mm') {
+        return value;
+    }
+    if (token === 'кг/мм' || token === 'kg/mm') {
+        return value * 1000;
+    }
+    if (!token && typeof (unit === null || unit === void 0 ? void 0 : unit.edizmId) === 'undefined') {
+        return value;
+    }
+    throw new Error(getUnitErrorText(key, unit));
+};
+const normalizeWorkpieceMassVariableValue = (context, key, value) => {
+    const unitKind = WORKPIECE_MASS_VARIABLE_UNIT_KINDS[key];
+    if (!unitKind)
+        return value;
+    const unitMeta = getVariableCharacteristicUnitMeta(context, key);
+    switch (unitKind) {
+        case 'length':
+            return normalizeLengthValue(value, key, unitMeta);
+        case 'area':
+            return normalizeAreaValue(value, key, unitMeta);
+        case 'density':
+            return normalizeDensityValue(value, key, unitMeta);
+        case 'linearMass':
+            return normalizeLinearMassValue(value, key, unitMeta);
+        default:
+            return value;
+    }
+};
+const normalizeWorkpieceMassVariables = (context, variables, variableKeys) => {
+    const result = Object.assign({}, variables);
+    for (const key of variableKeys) {
+        const value = result[key];
+        if (typeof value !== 'number' || Number.isNaN(value))
+            continue;
+        result[key] = normalizeWorkpieceMassVariableValue(context, key, value);
+    }
+    return result;
+};
+exports.normalizeWorkpieceMassVariables = normalizeWorkpieceMassVariables;
+/**
+ * Реестр источников значений переменных.
+ * Здесь описано, откуда брать каждую переменную под расчет массы заготовки.
+ */
+exports.WORKPIECE_MASS_VARIABLE_RESOLVERS = {
+    density: (context, prepared) => {
+        var _a;
+        return (_a = getPreparedValue(prepared, 'density')) !== null && _a !== void 0 ? _a : getMaterialCharacteristicValue(context, 'density');
+    },
+    length: (_context, prepared) => getPreparedValue(prepared, 'length'),
+    width: (_context, prepared) => getPreparedValue(prepared, 'width'),
+    height: (_context, prepared) => getPreparedValue(prepared, 'height'),
+    thickness: (_context, prepared) => getPreparedValue(prepared, 'thickness'),
+    wallThickness: (_context, prepared) => getPreparedValue(prepared, 'wallThickness'),
+    outsideDiameter: (_context, prepared) => getPreparedValue(prepared, 'outsideDiameter'),
+    areaCrossSectional: (_context, prepared) => getPreparedValue(prepared, 'areaCrossSectional'),
+    // TODO: добавить поле в model/type_material/material/workpiece_characterization
+    acrossFlats: (context, prepared) => {
+        var _a;
+        return (_a = getPreparedValue(prepared, 'acrossFlats')) !== null && _a !== void 0 ? _a : getMaterialCharacteristicValue(context, 'acrossFlats');
+    },
+    // TODO: добавить поле в material.characteristics или отдельную модель
+    massPerMeter: (context, prepared) => {
+        var _a;
+        return (_a = getPreparedValue(prepared, 'massPerMeter')) !== null && _a !== void 0 ? _a : getMaterialCharacteristicValue(context, 'massPerMeter');
+    }
+};
+const getRequiredVar = (vars, key) => {
+    const value = vars[key];
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        throw new Error(`Не заполнена переменная "${key}" для расчета массы заготовки`);
+    }
+    return value;
+};
+/**
+ * Реестр математических алгоритмов расчета.
+ * Здесь только математика, без поиска значений по моделям.
+ */
+exports.WORKPIECE_MASS_CALCULATORS = {
+    [enum_1.WorkpieceMassFormulaKey.boundingBox]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const length = getRequiredVar(vars, 'length');
+        const width = getRequiredVar(vars, 'width');
+        const height = getRequiredVar(vars, 'height');
+        return density * length * width * height;
+    },
+    [enum_1.WorkpieceMassFormulaKey.rectangularSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const length = getRequiredVar(vars, 'length');
+        const width = getRequiredVar(vars, 'width');
+        const thickness = getRequiredVar(vars, 'thickness');
+        return density * length * width * thickness;
+    },
+    [enum_1.WorkpieceMassFormulaKey.solidRoundSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const outsideDiameter = getRequiredVar(vars, 'outsideDiameter');
+        const length = getRequiredVar(vars, 'length');
+        return (density * Math.PI * Math.pow(outsideDiameter, 2) * length) / 4;
+    },
+    [enum_1.WorkpieceMassFormulaKey.hollowRoundSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const outsideDiameter = getRequiredVar(vars, 'outsideDiameter');
+        const wallThickness = getRequiredVar(vars, 'wallThickness');
+        const length = getRequiredVar(vars, 'length');
+        return (density *
+            Math.PI *
+            wallThickness *
+            (outsideDiameter - wallThickness) *
+            length);
+    },
+    [enum_1.WorkpieceMassFormulaKey.hollowProfileSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const width = getRequiredVar(vars, 'width');
+        const height = getRequiredVar(vars, 'height');
+        const wallThickness = getRequiredVar(vars, 'wallThickness');
+        const length = getRequiredVar(vars, 'length');
+        return (density *
+            (width * height -
+                (width - 2 * wallThickness) * (height - 2 * wallThickness)) *
+            length);
+    },
+    [enum_1.WorkpieceMassFormulaKey.hexSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const acrossFlats = getRequiredVar(vars, 'acrossFlats');
+        const length = getRequiredVar(vars, 'length');
+        return density * 0.866025 * Math.pow(acrossFlats, 2) * length;
+    },
+    [enum_1.WorkpieceMassFormulaKey.sectionArea]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const areaCrossSectional = getRequiredVar(vars, 'areaCrossSectional');
+        const length = getRequiredVar(vars, 'length');
+        return density * areaCrossSectional * length;
+    },
+    [enum_1.WorkpieceMassFormulaKey.linearMass]: vars => {
+        const massPerMeter = getRequiredVar(vars, 'massPerMeter');
+        const length = getRequiredVar(vars, 'length');
+        return massPerMeter * length;
+    }
+};
+const resolveWorkpieceMassVariables = (context, variableKeys) => {
+    var _a;
+    const prepared = getPreparedWorkpieceValues(context);
+    const result = {};
+    for (const key of variableKeys) {
+        result[key] =
+            (_a = exports.WORKPIECE_MASS_VARIABLE_RESOLVERS[key](context, prepared)) !== null && _a !== void 0 ? _a : undefined;
+    }
+    return (0, exports.normalizeWorkpieceMassVariables)(context, result, variableKeys);
+};
+exports.resolveWorkpieceMassVariables = resolveWorkpieceMassVariables;
+const calculateWorkpieceMassPreview = (context) => {
+    var _a;
+    const formulaKey = context.workpieceMassFormulaKey ||
+        ((_a = context.typeMaterial) === null || _a === void 0 ? void 0 : _a.workpieceMassFormulaKey) ||
+        null;
+    if (!formulaKey)
+        return null;
+    const formula = exports.WORKPIECE_MASS_FORMULAS.find(currentFormula => currentFormula.key === formulaKey);
+    if (!formula) {
+        throw new Error(`Формула расчета массы заготовки "${formulaKey}" не найдена`);
+    }
+    const variables = (0, exports.resolveWorkpieceMassVariables)(context, formula.variables.map(variable => variable.key));
+    return {
+        formulaKey,
+        mass: exports.WORKPIECE_MASS_CALCULATORS[formulaKey](variables),
+        variables
+    };
+};
+exports.calculateWorkpieceMassPreview = calculateWorkpieceMassPreview;

package/dist/material/workpiece-mass.d.ts

@@ -0,0 +1,45 @@
+import { WorkpieceMassFormulaKey } from './enum/enum';
+import type { ModelMaterial } from './schemas/material.schema';
+import type { ModelTypeMaterial } from './schemas/type-material.schema';
+export type TWorkpieceMassVariableKey = 'density' | 'length' | 'width' | 'height' | 'thickness' | 'wallThickness' | 'outsideDiameter' | 'areaCrossSectional' | 'acrossFlats' | 'massPerMeter';
+export interface IWorkpieceMassFormulaVariable {
+    key: TWorkpieceMassVariableKey;
+    name: string;
+    source: 'material' | 'workpiece';
+    required: boolean;
+}
+export interface IWorkpieceMassFormula {
+    key: WorkpieceMassFormulaKey;
+    name: string;
+    description: string;
+    variables: IWorkpieceMassFormulaVariable[];
+}
+export type TResolvedWorkpieceMassVariables = Partial<Record<TWorkpieceMassVariableKey, number>>;
+export interface ICalculateWorkpieceMassContext {
+    typeMaterial: ModelTypeMaterial;
+    material: ModelMaterial;
+    workpieceCharacterization?: Record<string, number | null | undefined>;
+    workpieceMassFormulaKey?: WorkpieceMassFormulaKey;
+}
+export interface ICalculateWorkpieceMassResult {
+    formulaKey: WorkpieceMassFormulaKey;
+    mass: number;
+    variables: TResolvedWorkpieceMassVariables;
+}
+type TPreparedWorkpieceValues = Partial<Record<TWorkpieceMassVariableKey | 'mass' | 'trash', number>>;
+type TWorkpieceMassVariableResolver = (context: ICalculateWorkpieceMassContext, prepared: TPreparedWorkpieceValues) => number | null;
+type TWorkpieceMassCalculator = (vars: TResolvedWorkpieceMassVariables) => number;
+export declare const WORKPIECE_MASS_FORMULAS: IWorkpieceMassFormula[];
+/**
+ * Реестр источников значений переменных.
+ * Здесь описано, откуда брать каждую переменную под расчет массы заготовки.
+ */
+export declare const WORKPIECE_MASS_VARIABLE_RESOLVERS: Record<TWorkpieceMassVariableKey, TWorkpieceMassVariableResolver>;
+/**
+ * Реестр математических алгоритмов расчета.
+ * Здесь только математика, без поиска значений по моделям.
+ */
+export declare const WORKPIECE_MASS_CALCULATORS: Record<WorkpieceMassFormulaKey, TWorkpieceMassCalculator>;
+export declare const resolveWorkpieceMassVariables: (context: ICalculateWorkpieceMassContext, variableKeys: TWorkpieceMassVariableKey[]) => TResolvedWorkpieceMassVariables;
+export declare const calculateWorkpieceMassPreview: (context: ICalculateWorkpieceMassContext) => ICalculateWorkpieceMassResult | null;
+export {};