@processandtools/rp-article-designer 1.0.14 → 1.0.16

package/dist/contexts/mat-surf/MatSurfContext.d.ts

@@ -0,0 +1,25 @@
+import { MaterialTypes } from '../../construction_principle/material/material.types';
+import { SurfaceTypes } from '../../construction_principle/surface/surface.types';
+export interface MatSurfContextValue {
+    materials: MaterialTypes[];
+    surfaces: SurfaceTypes[];
+    loadingMaterials: Set<string>;
+    loadingSurfaces: Set<string>;
+    failedMaterials: Set<string>;
+    failedSurfaces: Set<string>;
+    fetchMaterial: (name: string) => Promise<MaterialTypes | undefined>;
+    fetchSurface: (name: string) => Promise<SurfaceTypes | undefined>;
+    queueMaterialFetch: (name: string) => void;
+    queueSurfaceFetch: (name: string) => void;
+    isFetchingMaterial: (name: string) => boolean;
+    isFetchingSurface: (name: string) => boolean;
+    hasMaterial: (name: string) => boolean;
+    hasSurface: (name: string) => boolean;
+    hasFailedMaterial: (name: string) => boolean;
+    hasFailedSurface: (name: string) => boolean;
+}
+export declare const MatSurfContext: import('react').Context<MatSurfContextValue | undefined>;
+/**
+ * Hook to access material context
+ */
+export declare function useMatSurfs(): MatSurfContextValue;

package/dist/contexts/mat-surf/MatSurfProvider.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+import { MaterialTypes } from '../../construction_principle/material/material.types';
+import { SurfaceTypes } from '../../construction_principle/surface/surface.types';
+export interface MatSurfProviderProps {
+    children: ReactNode;
+    initialMaterials?: MaterialTypes[];
+    initialSurfaces?: SurfaceTypes[];
+}
+export declare function MatSurfProvider({ children, initialMaterials, initialSurfaces }: MatSurfProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/contexts/texture/TextureConfig.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+export interface TextureConfigContextType {
+    textureBaseUrl: string;
+    textureFolder?: string;
+    textureExtension?: string;
+    textureSuffix?: string;
+}
+export declare const TextureConfigContext: import('react').Context<TextureConfigContextType>;
+export interface TextureConfigProviderProps {
+    children: ReactNode;
+    config?: Partial<TextureConfigContextType>;
+}
+export declare function TextureConfigProvider({ children, config }: TextureConfigProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useTextureConfig(): TextureConfigContextType;
+export declare function buildTextureUrl(renderMat: string, config: TextureConfigContextType): string;

package/dist/descriptor/Descriptor.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/descriptor/helper/DescriptorEvaluator.d.ts

@@ -0,0 +1,7 @@
+import { DescriptorEvaluationResult, DescriptorNode, DescriptorResponse } from '../types/descriptor.types';
+import { DescriptorTypeValue } from '../types/descriptor-data.types';
+import { VariableTree } from '../../variables/VariableResolver';
+export declare class DescriptorEvaluator {
+    static evaluate<T extends DescriptorTypeValue>(descriptor: DescriptorResponse<T>, data: Record<string, unknown>, variableTree?: VariableTree): DescriptorEvaluationResult<T>;
+    static findAllNonDefaultMatches(descriptor: DescriptorResponse, data: Record<string, unknown>, variableTree?: VariableTree): DescriptorNode[];
+}

package/dist/descriptor/helper/descriptor-type-guards.d.ts

@@ -0,0 +1,6 @@
+import { DescriptorData, DescriptorTypeValue } from '../types/descriptor-data.types';
+import { DescriptorEvaluationResult } from '../types/descriptor.types';
+export declare function isStringData(data: DescriptorData): data is string;
+export declare function isLinDivResult(result: DescriptorEvaluationResult<DescriptorTypeValue>): result is DescriptorEvaluationResult<11>;
+export declare function isSidePanelResult(result: DescriptorEvaluationResult<DescriptorTypeValue>): result is DescriptorEvaluationResult<13>;
+export declare function isOtherResult(result: DescriptorEvaluationResult<DescriptorTypeValue>): result is DescriptorEvaluationResult<99>;

package/dist/descriptor/services/DescriptorManager.d.ts

@@ -0,0 +1,22 @@
+import { DescriptorResponse, DescriptorEvaluationResult } from '../types/descriptor.types';
+import { DescriptorTypeValue } from '../types/descriptor-data.types';
+import { VariableTree } from '../../variables/VariableResolver';
+export declare class DescriptorManager {
+    private descriptors;
+    private variableTree?;
+    constructor(descriptors: DescriptorResponse[], variableTree?: VariableTree);
+    evaluate<T extends DescriptorTypeValue = DescriptorTypeValue>(descriptorName: string, inputData: Record<string, unknown>): DescriptorEvaluationResult<T>;
+    getDescriptor(descriptorName: string): DescriptorResponse | undefined;
+    hasDescriptor(descriptorName: string): boolean;
+    getDescriptorNames(): string[];
+    getDescriptorsByType(descriptorType: DescriptorTypeValue): DescriptorResponse[];
+    findAllMatches(descriptorName: string, inputData: Record<string, unknown>): import('../types/descriptor.types').DescriptorNode<DescriptorTypeValue>[];
+    getStats(): {
+        total: number;
+        byType: Record<number, number>;
+        names: string[];
+    };
+}
+export declare function createDescriptorManager(jsonData: DescriptorResponse[] | {
+    descriptors: DescriptorResponse[];
+}, variableTree?: VariableTree): DescriptorManager;

package/dist/descriptor/types/descriptor-data.types.d.ts

@@ -0,0 +1,15 @@
+export declare const DescriptorType: {
+    readonly LIN_DIV: 11;
+    readonly SIDE_PANEL: 13;
+    readonly OTHER: 99;
+};
+export type DescriptorTypeValue = typeof DescriptorType[keyof typeof DescriptorType];
+export type LinDivData = string;
+export type SidePanelData = string;
+export type OtherDescriptorData = string;
+export type DescriptorData = LinDivData | SidePanelData | OtherDescriptorData;
+export type DescriptorDataTypeMap = {
+    11: LinDivData;
+    13: SidePanelData;
+    99: OtherDescriptorData;
+};

package/dist/descriptor/types/descriptor.types.d.ts

@@ -0,0 +1,31 @@
+import { ConditionTreeResponse } from '../../conditions/types/condition.types';
+import { DescriptorDataTypeMap, DescriptorTypeValue } from './descriptor-data.types';
+export interface DescriptorResponse<T extends DescriptorTypeValue = DescriptorTypeValue> {
+    descriptor: DescriptorInfo<T>;
+    nodes: DescriptorNode<T>[];
+}
+export interface DescriptorInfo<T extends DescriptorTypeValue = DescriptorTypeValue> {
+    NAME: string;
+    COMMENT: string;
+    SAMPDIM: number;
+    INORDER: string;
+    DATE_LASTCHANGE: string;
+    SOURCE: string;
+    PRODUCER: string;
+    SYS: boolean;
+    DESC_TYPE: T;
+}
+export interface DescriptorNode<T extends DescriptorTypeValue = DescriptorTypeValue> {
+    nodeNum: number;
+    lindiv: DescriptorDataTypeMap[T];
+    comment: string;
+    conditionId: number;
+    conditionTree: ConditionTreeResponse | null;
+}
+export interface DescriptorEvaluationResult<T extends DescriptorTypeValue = DescriptorTypeValue> {
+    lindiv: DescriptorDataTypeMap[T];
+    descriptorType: T;
+    nodeNum: number;
+    matched: boolean;
+    isDefault: boolean;
+}

package/dist/helpers/CheckUrlExists.d.ts

@@ -0,0 +1 @@
+export declare function CheckUrlExists(url: string): Promise<boolean>;

package/dist/helpers/CpDispatcher.d.ts

@@ -0,0 +1,53 @@
+import { CPTypeCode } from '../types/cp.types';
+export default function CpDispatcher(CpName: string, PartType: CPTypeCode): {
+    kms: {
+        name: string | undefined;
+        material: {
+            renderInfo: {
+                textureId: undefined;
+                isValid: boolean;
+            } | {
+                textureId: string;
+                isValid: boolean;
+            };
+            NAME: string;
+            TEXT: string;
+            THK: number;
+            MATCAT: string;
+            GRAIN: number;
+            RENDER: string;
+        } | undefined;
+        surfaceTop: {
+            renderInfo: {
+                textureId: undefined;
+                isValid: boolean;
+            } | {
+                textureId: string;
+                isValid: boolean;
+            };
+            NAME: string;
+            TEXT: string;
+            THK: number;
+            SURFCAT: string;
+            GRAIN: number;
+            RENDER: string;
+        } | undefined;
+        surfaceBot: {
+            renderInfo: {
+                textureId: undefined;
+                isValid: boolean;
+            } | {
+                textureId: string;
+                isValid: boolean;
+            };
+            NAME: string;
+            TEXT: string;
+            THK: number;
+            SURFCAT: string;
+            GRAIN: number;
+            RENDER: string;
+        } | undefined;
+        render: string | undefined;
+        thk: number;
+    };
+} | undefined;

package/dist/helpers/ExpressionResolver.d.ts

@@ -0,0 +1,43 @@
+import { VariableTree } from '../variables/VariableResolver';
+export interface ResolveOptions {
+    variableTree?: VariableTree;
+    dataType?: 'FL' | 'IN' | 'CI' | 'CS' | 'DA' | string;
+    silent?: boolean;
+    allowFunctions?: boolean;
+}
+export interface ResolveResult {
+    value: number | string | undefined;
+    original: string;
+    resolved: string;
+    hadVariables: boolean;
+    wasEvaluated: boolean;
+    unit?: string;
+    error?: string;
+}
+export declare function resolve(input: string, options?: ResolveOptions): ResolveResult;
+export declare function resolveValue(input: string, options?: ResolveOptions): number | string | undefined;
+/**
+ * Check if a string is an IF statement
+ */
+export declare function isIfStatement(str: string): boolean;
+/**
+ * Parse and evaluate an IF statement
+ * Format: IF(condition, trueValue, falseValue)
+ *
+ * Supports:
+ * - Comparisons: =, !=, <, >, <=, >=
+ * - Logical: AND, OR, NOT
+ * - Nested IF statements
+ *
+ * @example
+ * evaluateIfStatement("IF(1 = 1, -150, 150)") // → -150
+ * evaluateIfStatement("IF(5 > 3, 100, 200)") // → 100
+ */
+export declare function evaluateIfStatement(expr: string, allowFunctions?: boolean): number | string;
+export declare function isMathExpression(str: string): boolean;
+export declare function evaluateExpression(expr: string, allowFunctions?: boolean): number;
+export declare function clearCache(): void;
+export declare function resolveMany(inputs: string[], options?: ResolveOptions): ResolveResult[];
+export declare function resolveObject<T extends Record<string, unknown>>(obj: T, options?: ResolveOptions): T;
+export declare function inspect(input: string, options?: ResolveOptions): ResolveResult;
+export declare function canResolve(input: string, options?: ResolveOptions): boolean;

package/dist/helpers/GroupWrapper.d.ts

@@ -0,0 +1,10 @@
+import { VIEW } from '../types/view.types';
+import { FC, ReactNode } from 'react';
+interface GroupWrapperProps {
+    view: VIEW;
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+    children?: ReactNode;
+}
+declare const GroupWrapper: FC<GroupWrapperProps>;
+export default GroupWrapper;

package/dist/helpers/LinDivHelper.d.ts

@@ -0,0 +1,3 @@
+import { ChildrenDimsResult, DimensionProps } from '../types/zone.types';
+import { DividerMode } from '../types/divider.types';
+export default function LinDivHelper(divider: DividerMode, dimensions: DimensionProps, dividerThickness: number | 0): ChildrenDimsResult;

package/dist/helpers/LinDivPatternTransform.d.ts

@@ -0,0 +1,2 @@
+export declare function LinDivPatternTransform(input: string): string;
+export declare function extractNumberFromIndependentDiv(input: string): number | string;

package/dist/helpers/LindivResolver.d.ts

@@ -0,0 +1,58 @@
+import { VariableTree } from '../variables/VariableResolver';
+export interface LindivResult {
+    /** Resolved lindiv string in original format (e.g., "3600mm:1", "1:1800mm") */
+    value: string;
+    /** Original input string */
+    original: string;
+    /** Whether this is a reference (starts with # or is article name) */
+    isReference: boolean;
+}
+/**
+ * Resolve lindiv expressions and return in original format
+ *
+ * Handles:
+ * - Simple ratios: "1:1", "2:1" → "1:1"
+ * - References: "#RP_LD_P_T100" → "RP_LD_P_T100"
+ * - Expressions: "(round(4000/1200 -0.5)*1200)mm:1" → "3600mm:1"
+ * - Reverse format: "1:((round(2700/150))*150)mm" → "1:1800mm"
+ * - With braces: "(round(X/150))*{1}" → "24*{1}"
+ * - With variables: Assumes variables are already resolved
+ *
+ * @example
+ * resolveLindiv("(round(4000/1200 -0.5)*1200)mm:1")
+ * // → "3600mm:1"
+ *
+ * @example
+ * resolveLindiv("1:((round(2700/150))*150)mm")
+ * // → "1:1800mm"
+ *
+ * @example
+ * resolveLindiv("#RP_LD_P_T100")
+ * // → "RP_LD_P_T100" (removes #)
+ */
+export declare function resolveLindiv(lindiv: string, variableTree?: VariableTree): LindivResult;
+/**
+ * Simpler version that just returns the resolved string value
+ *
+ * @example
+ * resolveLindivValue("(round(4000/1200 -0.5)*1200)mm:1")
+ * // → "3600mm:1"
+ */
+export declare function resolveLindivValue(lindiv: string, variableTree?: VariableTree): string;
+/**
+ * Check if lindiv is a reference (descriptor name or article name)
+ */
+export declare function isLindivReference(lindiv: string): boolean;
+/**
+ * Check if a lindiv expression contains variables
+ */
+export declare function lindivHasVariables(lindiv: string): boolean;
+/**
+ * Extract variable names from lindiv
+ */
+export declare function extractLindivVariables(lindiv: string): string[];
+/**
+ * Format lindiv result back to string
+ * Since value is already formatted, this just adds # for references
+ */
+export declare function formatLindiv(result: LindivResult): string;

package/dist/helpers/MitreCalc.d.ts

@@ -0,0 +1,11 @@
+import { Shape } from 'three';
+interface Point2D {
+    x: number;
+    y: number;
+}
+export declare function calculateMitrePoints(length: number, thickness: number, startPanelThk?: number, endPanelThk?: number): {
+    points: Point2D[];
+    readonly svgPath: string;
+    readonly shape: Shape;
+};
+export {};

package/dist/helpers/PositionHelper.d.ts

@@ -0,0 +1,10 @@
+import { DimensionProps, PositionHelperResult } from '../types/zone.types';
+interface PositionHelperParams {
+    divisionType: 'width' | 'depth' | 'height' | 'article' | 'independent';
+    parentDimensions: DimensionProps;
+    lengthList: number[];
+    childTREEIDs: string[];
+    dividerThk: number;
+}
+export default function PositionHelper({ divisionType, parentDimensions, lengthList, childTREEIDs, dividerThk }: PositionHelperParams): PositionHelperResult;
+export {};

package/dist/helpers/VariableHelper.d.ts

@@ -0,0 +1,2 @@
+export declare const extractVars: (str: string) => string[];
+export declare const hasVars: (str: string) => boolean;

package/dist/helpers/WallTransform.d.ts

@@ -0,0 +1,6 @@
+import { Point } from '../types/primitives.types';
+export declare function calculateWallTransformVector3(startPoint: Point, endPoint: Point): {
+    position: [number, number, number];
+    rotation: [number, number, number];
+    length: number;
+};

package/dist/helpers/WallTransformGeo.d.ts

@@ -0,0 +1,6 @@
+import { WallProps } from '../types/wall.types';
+export declare function wallTransformGeometry(wallData: WallProps): {
+    length: number;
+    position: [number, number, number];
+    rotation: [number, number, number];
+};