@3driseai/3drise-core 1.0.1

package/dist/utils/dataUtils.js

@@ -0,0 +1,471 @@
+import _ from 'lodash';
+export const isValidNumber = (val) => {
+    // console.log('val', val == "")
+    let isValid = true;
+    if (val === '-' || val === '' || isNaN(Number(val))) {
+        isValid = false;
+    }
+    return isValid;
+};
+export const cleanObject = (obj) => {
+    if (!obj || typeof obj !== 'object')
+        return obj;
+    const cleaned = {};
+    Object.keys(obj).forEach(key => {
+        // Skip properties that start with 'field'
+        if (key.toLowerCase().startsWith('field')) {
+            return;
+        }
+        const value = obj[key];
+        if (typeof value === 'string' && value.startsWith('{')) {
+            return;
+        }
+        if (typeof value === 'string' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean' ||
+            value === null ||
+            value === undefined) {
+            cleaned[key] = value;
+        }
+        // Skip arrays, objects, functions, etc.
+    });
+    return cleaned;
+};
+export const getLastCreateditem = (items) => [...items].sort((a, b) => b.id - a.id)[0];
+export const getFileNameByString = (str, items) => items.filter(item => item.name.includes(str));
+export const sortBy = (data, field, reverse) => {
+    const array = [...data];
+    if (reverse) {
+        array.sort((a, b) => a[field] < b[field] ? 1 : b[field] < a[field] ? -1 : 0);
+    }
+    else {
+        array.sort((a, b) => a[field] > b[field] ? 1 : b[field] > a[field] ? -1 : 0);
+    }
+    //
+    return array;
+};
+export const createSurveyTasksTree = (surveys, bridgeTasks) => {
+    const tree = surveys
+        // .filter((surv) => surv.id === displayedSurvey.id)
+        .map((survey) => {
+        const tasks = sortBy(bridgeTasks.filter((task) => task.survey_id === survey.id), 'task_order').map((task) => {
+            return {
+                ...task,
+                children: task.sub_tasks.map((subTask) => ({
+                    ...subTask,
+                    parentTask: task,
+                })),
+            };
+        });
+        return {
+            ...survey,
+            children: tasks,
+        };
+    });
+    return tree;
+};
+export const getAnnotationsByImageName = (imageName, annotations) => {
+    const newAnnotations = [];
+    annotations.forEach(ann => ann.annotations &&
+        ann.annotations.forEach((ann) => {
+            const newAnnotation = { ...ann };
+            newAnnotation.defect = ann;
+            imageName.includes(ann.image_name) && newAnnotations.push(newAnnotation);
+        }));
+    return newAnnotations;
+};
+export function getDataByField(data, field, value) {
+    return data.filter((el) => el[field] == value);
+}
+export const getUniqueValuesFromColumn = (field, data) => {
+    //
+    const uniqueValues = [];
+    data.map(row => {
+        if (row &&
+            row[field] &&
+            row[field] !== '' &&
+            !uniqueValues.includes(row[field]))
+            uniqueValues.push(row[field]);
+    });
+    //
+    return uniqueValues;
+};
+export const isNumber = (value) => typeof value === 'number' || (!isNaN(Number(value)) && value !== null && value !== '') || value === Infinity || value === -Infinity;
+export function isDateValue(value) {
+    if (value instanceof Date && !isNaN(value.getTime()))
+        return true;
+    // Check if it's a string that can be parsed to a valid date
+    if (typeof value === 'string') {
+        // First, check if it looks like a date format
+        const datePatterns = [
+            /^\d{4}-\d{2}-\d{2}$/, // YYYY-MM-DD
+            /^\d{2}\/\d{2}\/\d{4}$/, // MM/DD/YYYY
+            /^\d{2}-\d{2}-\d{4}$/, // MM-DD-YYYY
+            /^\d{4}\/\d{2}\/\d{2}$/, // YYYY/MM/DD
+            /^\d{1,2}\/\d{1,2}\/\d{4}$/, // M/D/YYYY or MM/DD/YYYY
+            /^\d{4}-\d{1,2}-\d{1,2}$/, // YYYY-M-D or YYYY-MM-DD
+            /^\w{3}\s+\d{1,2},?\s+\d{4}$/, // Mon DD, YYYY or Mon DD YYYY
+            /^\d{1,2}\s+\w{3}\s+\d{4}$/, // DD Mon YYYY
+            /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/ // ISO format
+        ];
+        // Check if the string matches common date patterns
+        const looksLikeDate = datePatterns.some(pattern => pattern.test(value.trim()));
+        if (!looksLikeDate) {
+            return false;
+        }
+        // If it looks like a date, then try to parse it
+        const d = new Date(value);
+        return !isNaN(d.getTime());
+    }
+    return false;
+}
+export function parseJsonWithFixedControlChars(jsonString) {
+    // Check for bad control characters
+    if (/[\u0000-\u001f]/.test(jsonString)) {
+        // Replace bad control characters with their escaped equivalents
+        jsonString = jsonString.replace(/[\u0000-\u001f]/g, function (match) {
+            return `\\u${(`0000${match.charCodeAt(0).toString(16)}`).slice(-4)}`;
+        });
+    }
+    return JSON.parse(jsonString);
+}
+export const fixAndParseJson = (jsonString) => {
+    try {
+        // console.log("fixAndParseJson", jsonString);
+        console.log(/[\u0000-\u001f]/.test(jsonString));
+        if (/[\u0000-\u001f]/.test(jsonString)) {
+            // Replace bad control characters with their escaped equivalents
+            jsonString = jsonString.replace(/[\u0000-\u001f]/g, function (match) {
+                return `\\u${(`0000${match.charCodeAt(0).toString(16)}`).slice(-4)}`;
+            });
+            return JSON.parse(jsonString);
+        }
+        else {
+            for (let i = 0; i < jsonString.length; i++) {
+                if (jsonString.charCodeAt(i) < 32) {
+                    // Replace bad control characters with their escaped equivalents
+                    jsonString = jsonString.replace(/[\u0000-\u001f]/g, function (match) {
+                        return `\\u${(`0000${match.charCodeAt(0).toString(16)}`).slice(-4)}`;
+                    });
+                    break;
+                }
+            }
+            // If no bad control characters are found, parse the JSON string directly
+            return JSON.parse(jsonString);
+        }
+    }
+    catch (e) {
+        console.error("Error fixing JSON string:", e);
+        // If there's an error, return the original string or handle it as needed
+        return null;
+    }
+};
+export function onlyUnique(value, index, self) {
+    return self.indexOf(value) === index;
+}
+export const getUniqueByField = (field, data) => {
+    const uniqueValues = [];
+    const returnedData = [];
+    data.forEach((item) => {
+        if (item && item[field] && !uniqueValues.includes(item[field])) {
+            uniqueValues.push(item[field]);
+            returnedData.push(item);
+        }
+    });
+    return returnedData;
+};
+export const sortByFields = (fields, data) => _.cloneDeep(data).sort(function (a, b) {
+    // Sort by name
+    fields.forEach(field => {
+        if (a[field] < b[field])
+            return -1;
+        if (a[field] > b[field])
+            return 1;
+    });
+    return 0; // names, age and city are equal
+});
+export const getMinOfField = (fieldName, data) => {
+    let min = data[0][fieldName];
+    data.forEach(element => {
+        if (element[fieldName] < min)
+            min = element[fieldName];
+    });
+    return min;
+};
+export const getMaxOfField = (fieldName, data) => {
+    let max = data[0][fieldName];
+    data.forEach(element => {
+        if (element[fieldName] > max)
+            max = element[fieldName];
+    });
+    return max;
+};
+export const getSumOfField = (fieldName, data) => {
+    let sum = 0;
+    data.forEach(element => {
+        sum += element[fieldName];
+    });
+    return sum;
+};
+export const calculateBridgeScs = (spans) => {
+    let scs = 0;
+    //
+    const sumSpansArea = getSumOfField('span_area', spans);
+    //
+    spans.forEach(span => {
+        scs += span.SCS * (span.span_area / sumSpansArea);
+    });
+    return scs;
+};
+export const calculateBridgeCpi = (spans) => {
+    let cpi = 0;
+    const sumSpansArea = getSumOfField('span_area', spans);
+    spans.forEach(span => {
+        cpi += span.CPI * (span.span_area / sumSpansArea);
+    });
+    return cpi;
+};
+export const getSeveritiesFromElementDefectRating = (defectRating, severities, imageAnnotations) => Object.keys(defectRating)
+    .map(defectCode => {
+    // console.log(defectRating[defectCode]);
+    if (defectRating[defectCode] &&
+        defectRating[defectCode].severity &&
+        defectRating[defectCode].severity.length) {
+        return defectRating[defectCode].severity;
+    }
+    const heighest = getHighesSeverityFromAnnotations(imageAnnotations.filter(ann => ann.defect_code == defectCode), severities);
+    return heighest && heighest.description;
+})
+    .map(sev => severities.find(severity => severity.description == sev));
+export const getExtentsFromElementDefectRating = (defectRating, extents) => Object.keys(defectRating)
+    .map(defectCode => defectRating[defectCode].extent)
+    .map(ext => extents.find(extent => extent.description == ext));
+export const getHighesSeverityFromAnnotations = (annotations, severities) => {
+    const annotationsSeveritis = annotations.map(ann => severities.find(severity => ann.severity == severity.description));
+    const uniqueSeverities = getUniqueValuesFromColumn('severity', annotationsSeveritis).sort();
+    const highestSeverity = severities.find(sev => sev.severity == uniqueSeverities[uniqueSeverities.length - 1]);
+    return highestSeverity;
+};
+export const getFileNameFromDirectoryPath = (path) => {
+    const parts = path.split('/');
+    return parts[parts.length - 1];
+};
+export const getFolderAndFileName = (path) => {
+    let folder = '';
+    let fileName = '';
+    if (path) {
+        const parts = path.split('Images/');
+        folder = parts[1];
+        fileName = folder.split('/').pop() || '';
+        folder = folder.replace(fileName, '');
+    }
+    return { folder, fileName };
+};
+export const extractJsonFromText = (text) => {
+    if (!text)
+        return [];
+    const jsonResults = [];
+    try {
+        const fullJson = JSON.parse(text.trim());
+        jsonResults.push(fullJson);
+        return jsonResults;
+    }
+    catch {
+        // Continue to other methods
+    }
+    // Extract JSON from markdown code blocks
+    const codeBlockRegex = /```(?:json|javascript|js)?\s*\n?([\s\S]*?)\n?```/gi;
+    let match;
+    while ((match = codeBlockRegex.exec(text)) !== null) {
+        try {
+            const jsonContent = match[1].trim();
+            const parsed = JSON.parse(jsonContent);
+            jsonResults.push(parsed);
+        }
+        catch (error) {
+            console.warn("Failed to parse JSON from code block:", error);
+        }
+    }
+    // Extract JSON objects/arrays using regex
+    const jsonRegex = /(\{[\s\S]*?\}|\[[\s\S]*?\])/g;
+    let jsonMatch;
+    while ((jsonMatch = jsonRegex.exec(text)) !== null) {
+        try {
+            const jsonString = jsonMatch[1];
+            if (jsonString.includes(':') || jsonString.includes('[')) {
+                const parsed = JSON.parse(jsonString);
+                if (!jsonResults.some(existing => JSON.stringify(existing) === JSON.stringify(parsed))) {
+                    jsonResults.push(parsed);
+                }
+            }
+        }
+        catch (error) {
+            // Skip invalid JSON
+        }
+    }
+    return jsonResults;
+};
+export const analyzeModel = (model) => {
+    const modelAnalysis = {
+        interactibles: [],
+        meshes: 0,
+        materials: 0,
+        textures: 0,
+        unNamedMeshes: 0,
+    };
+    // console.log("analyzeModel model:", model);
+    model.traverse((child) => {
+        if (child.isMesh) {
+            modelAnalysis.meshes++;
+            if (child.name && child.name !== "" && !child.name.toLowerCase().includes('mesh')) {
+                child.userData = {
+                    ...child.userData,
+                    interactible: true,
+                };
+                modelAnalysis.interactibles.push(child);
+                // console.log("Setting interactible for mesh:", child.name);
+            }
+            else {
+                modelAnalysis.unNamedMeshes++;
+            }
+        }
+    });
+    return modelAnalysis;
+};
+export const processModel = (model) => {
+    const modelAnalysis = {
+        interactibles: [],
+        meshes: 0,
+        materials: 0,
+        textures: 0,
+        unNamedMeshes: 0,
+    };
+    console.log("Processing model:", model);
+    model.traverse((child) => {
+        if (child.isMesh) {
+            modelAnalysis.meshes++;
+            if (!child.name.toLowerCase().includes('mesh')) {
+                child.userData = {
+                    interactible: true,
+                };
+                modelAnalysis.interactibles.push(child);
+                // console.log("Setting interactible for mesh:", child.name);
+            }
+            else {
+                modelAnalysis.unNamedMeshes++;
+            }
+        }
+    });
+    return modelAnalysis;
+};
+export const getType = (property, value) => {
+    const isVector3 = (value) => {
+        return Array.isArray(value) && value.length === 3;
+    };
+    const isAnchor = (value) => {
+        return property.toLowerCase().includes('anchor');
+    };
+    const isVector2 = (value) => {
+        return Array.isArray(value) && value.length === 2;
+    };
+    const isVector4 = (value) => {
+        return Array.isArray(value) && value.length === 4;
+    };
+    const isShape = () => {
+        return property.toLowerCase().includes('shape');
+        // && property.toLowerCase().includes('type');
+    };
+    const isFont = () => {
+        return property === 'font';
+        // && property.toLowerCase().includes('type');
+    };
+    const isRenderMode = () => {
+        return property === 'renderMode';
+    };
+    const isGeometry = () => {
+        return property.toLowerCase().includes('geometry');
+        // && property.toLowerCase().includes('type');
+    };
+    const isLayout = () => {
+        return property.toLowerCase() === 'layout';
+        // && property.toLowerCase().includes('type');
+    };
+    const isHexColor = (value) => {
+        if (typeof value === "string") {
+            // Supports #RGB, #RGBA, #RRGGBB, #RRGGBBAA
+            const hexRegex = /^#([0-9A-F]{3}|[0-9A-F]{4}|[0-9A-F]{6}|[0-9A-F]{8})$/i;
+            return hexRegex.test(value);
+        }
+        return false;
+    };
+    const isAnimation = () => property === "animationId";
+    const isSide = () => property === "side";
+    const isAxis = () => property === "axis";
+    const isColorProperty = () => property.toLowerCase().includes("color");
+    const isTexture = (prop) => {
+        const lower = prop.toLowerCase();
+        return lower.includes("texture") || lower === "map" || lower.endsWith("map");
+    };
+    const iseNoise = (prop) => {
+        const lower = prop.toLowerCase();
+        return lower.includes("noise") && !lower.includes("texture");
+    };
+    if (typeof value === "boolean") {
+        return "checkbox";
+    }
+    if (isAnchor(value)) {
+        return "anchor";
+    }
+    if (isRenderMode()) {
+        return "renderMode";
+    }
+    if (isLayout()) {
+        return "layout";
+    }
+    if (isShape()) {
+        return "shapeType";
+    }
+    if (isGeometry()) {
+        return "geometryType";
+    }
+    if (isFont()) {
+        return "font";
+    }
+    if (isHexColor(value) || isColorProperty()) {
+        return "color";
+    }
+    if (isVector3(value)) {
+        return "vector3";
+    }
+    if (isVector2(value)) {
+        return "vector2";
+    }
+    if (isVector4(value)) {
+        return "vector4";
+    }
+    if (isTexture(property)) {
+        return "texture";
+    }
+    if (iseNoise(property)) {
+        return "noise";
+    }
+    if (isSide()) {
+        return "side";
+    }
+    if (isAxis()) {
+        return "axis";
+    }
+    if (property === 'ease') {
+        return "ease";
+    }
+    if (isAnimation()) {
+        return "animation";
+    }
+    // if (property.includes("scale") || property.includes("Scale")) {
+    //   return "vector3";
+    // }
+    // if (property.includes("rotation") || property.includes("Rotation")) {
+    //   return "vector3";
+    // }
+    return typeof value;
+};

package/dist/utils/easingUtils.d.ts

@@ -0,0 +1,5 @@
+export declare const easingFunctions: Record<string, (t: number) => number>;
+export declare const applyEasing: (easingName: string, progress: number) => number;
+export declare const gsapEasingMap: Record<string, string>;
+export declare const resolveEasing: (ease: string) => string;
+//# sourceMappingURL=easingUtils.d.ts.map

package/dist/utils/easingUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"easingUtils.d.ts","sourceRoot":"","sources":["../../src/utils/easingUtils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAmEjE,CAAC;AACF,eAAO,MAAM,WAAW,GAAI,YAAY,MAAM,EAAE,UAAU,MAAM,KAAG,MAGlE,CAAC;AACF,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAYhD,CAAC;AACF,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,MAAqC,CAAC"}

package/dist/utils/easingUtils.js

@@ -0,0 +1,86 @@
+export const easingFunctions = {
+    linear: (t) => t,
+    easeInQuad: (t) => t * t,
+    easeOutQuad: (t) => t * (2 - t),
+    easeInOutQuad: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+    easeInCubic: (t) => t * t * t,
+    easeOutCubic: (t) => --t * t * t + 1,
+    easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1,
+    easeInQuart: (t) => t * t * t * t,
+    easeOutQuart: (t) => 1 - --t * t * t * t,
+    easeInOutQuart: (t) => t < 0.5 ? 8 * t * t * t * t : 1 - 8 * (--t) * t * t * t,
+    easeInQuint: (t) => t * t * t * t * t,
+    easeOutQuint: (t) => 1 + --t * t * t * t * t,
+    easeInOutQuint: (t) => t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * (--t) * t * t * t * t,
+    easeInSine: (t) => 1 - Math.cos(t * Math.PI / 2),
+    easeOutSine: (t) => Math.sin(t * Math.PI / 2),
+    easeInOutSine: (t) => -(Math.cos(Math.PI * t) - 1) / 2,
+    easeInExpo: (t) => t === 0 ? 0 : Math.pow(2, 10 * (t - 1)),
+    easeOutExpo: (t) => t === 1 ? 1 : 1 - Math.pow(2, -10 * t),
+    easeInOutExpo: (t) => {
+        if (t === 0 || t === 1)
+            return t;
+        return t < 0.5 ? Math.pow(2, 20 * t - 10) / 2 : (2 - Math.pow(2, -20 * t + 10)) / 2;
+    },
+    easeInCirc: (t) => 1 - Math.sqrt(1 - t * t),
+    easeOutCirc: (t) => Math.sqrt(1 - --t * t),
+    easeInOutCirc: (t) => t < 0.5
+        ? (1 - Math.sqrt(1 - 4 * t * t)) / 2
+        : (Math.sqrt(1 - (-2 * t + 2) ** 2) + 1) / 2,
+    easeInBack: (t) => { const c = 1.70158; return t * t * ((c + 1) * t - c); },
+    easeOutBack: (t) => { const c = 1.70158; return 1 + --t * t * ((c + 1) * t + c); },
+    easeInOutBack: (t) => {
+        const c = 1.70158 * 1.525;
+        return t < 0.5
+            ? (2 * t) ** 2 * ((c + 1) * 2 * t - c) / 2
+            : ((2 * t - 2) ** 2 * ((c + 1) * (2 * t - 2) + c) + 2) / 2;
+    },
+    easeInElastic: (t) => {
+        if (t === 0 || t === 1)
+            return t;
+        return -Math.pow(2, 10 * t - 10) * Math.sin((t * 10 - 10.75) * (2 * Math.PI) / 3);
+    },
+    easeOutElastic: (t) => {
+        if (t === 0 || t === 1)
+            return t;
+        return Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * (2 * Math.PI) / 3) + 1;
+    },
+    easeInOutElastic: (t) => {
+        if (t === 0 || t === 1)
+            return t;
+        return t < 0.5
+            ? -(Math.pow(2, 20 * t - 10) * Math.sin((20 * t - 11.125) * (2 * Math.PI) / 4.5)) / 2
+            : (Math.pow(2, -20 * t + 10) * Math.sin((20 * t - 11.125) * (2 * Math.PI) / 4.5)) / 2 + 1;
+    },
+    easeInBounce: (t) => 1 - easingFunctions.easeOutBounce(1 - t),
+    easeOutBounce: (t) => {
+        if (t < 1 / 2.75)
+            return 7.5625 * t * t;
+        if (t < 2 / 2.75)
+            return 7.5625 * (t -= 1.5 / 2.75) * t + 0.75;
+        if (t < 2.5 / 2.75)
+            return 7.5625 * (t -= 2.25 / 2.75) * t + 0.9375;
+        return 7.5625 * (t -= 2.625 / 2.75) * t + 0.984375;
+    },
+    easeInOutBounce: (t) => t < 0.5
+        ? (1 - easingFunctions.easeOutBounce(1 - 2 * t)) / 2
+        : (1 + easingFunctions.easeOutBounce(2 * t - 1)) / 2,
+};
+export const applyEasing = (easingName, progress) => {
+    const fn = easingFunctions[easingName];
+    return fn ? fn(progress) : progress;
+};
+export const gsapEasingMap = {
+    'power1.in': 'easeInQuad', 'power1.out': 'easeOutQuad', 'power1.inOut': 'easeInOutQuad',
+    'power2.in': 'easeInCubic', 'power2.out': 'easeOutCubic', 'power2.inOut': 'easeInOutCubic',
+    'power3.in': 'easeInQuart', 'power3.out': 'easeOutQuart', 'power3.inOut': 'easeInOutQuart',
+    'power4.in': 'easeInQuint', 'power4.out': 'easeOutQuint', 'power4.inOut': 'easeInOutQuint',
+    'sine.in': 'easeInSine', 'sine.out': 'easeOutSine', 'sine.inOut': 'easeInOutSine',
+    'expo.in': 'easeInExpo', 'expo.out': 'easeOutExpo', 'expo.inOut': 'easeInOutExpo',
+    'circ.in': 'easeInCirc', 'circ.out': 'easeOutCirc', 'circ.inOut': 'easeInOutCirc',
+    'back.in': 'easeInBack', 'back.out': 'easeOutBack', 'back.inOut': 'easeInOutBack',
+    'elastic.in': 'easeInElastic', 'elastic.out': 'easeOutElastic', 'elastic.inOut': 'easeInOutElastic',
+    'bounce.in': 'easeInBounce', 'bounce.out': 'easeOutBounce', 'bounce.inOut': 'easeInOutBounce',
+    'linear': 'linear',
+};
+export const resolveEasing = (ease) => gsapEasingMap[ease] ?? ease;

package/dist/utils/edgeUtils.d.ts

@@ -0,0 +1,37 @@
+import { BufferGeometry, Matrix4, Mesh, Vector3 } from "three";
+import type { Object3D } from 'three';
+export interface MeshEntry {
+    mesh: Mesh;
+    /** transform relative to the root object */
+    matrixRelativeToRoot: Matrix4;
+}
+export interface EdgeSegment {
+    start: Vector3;
+    end: Vector3;
+}
+/** Recursively collect all meshes with geometries, accumulating local matrices. */
+export declare function collectMeshes(obj: Object3D, parentMatrix?: Matrix4): MeshEntry[];
+/** Pick edge threshold based on bounding box shape. */
+export declare function computeThreshold(geometry: BufferGeometry): number;
+/**
+ * Extract all edge segments from an Object3D (or group).
+ * Each segment is in the coordinate space of the root object.
+ */
+export declare function extractEdgeSegments(object: Object3D): EdgeSegment[];
+/**
+ * Sample `countPerEdge` evenly-spaced points along every edge.
+ * Returns flat array of Vector3 positions and matching per-point edge indices.
+ */
+export declare function sampleEdgePoints(segments: EdgeSegment[], countPerEdge: number): {
+    positions: Float32Array;
+    progress: Float32Array;
+    edgeIndex: Float32Array;
+};
+/**
+ * Build a single pre-baked dense LineSegments geometry for all edges of an object.
+ * Every edge is subdivided into `subdivisions` segments.
+ * Per-vertex attributes: position, aProgress (0..1), aEdgePhase (golden-ratio spread), aEdgeFreq (0.25..0.5 Hz)
+ * Indices form connected pairs so LineSegments renders them as solid continuous lines per edge.
+ */
+export declare function buildSubdividedEdgeGeometry(object: Object3D, subdivisions?: number, parentMatrix?: Matrix4): BufferGeometry;
+//# sourceMappingURL=edgeUtils.d.ts.map

package/dist/utils/edgeUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edgeUtils.d.ts","sourceRoot":"","sources":["../../src/utils/edgeUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,cAAc,EAAiB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAC/F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC,MAAM,WAAW,SAAS;IACtB,IAAI,EAAE,IAAI,CAAC;IACX,4CAA4C;IAC5C,oBAAoB,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,WAAW;IACxB,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,OAAO,CAAC;CAChB;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAAC,GAAG,EAAE,QAAQ,EAAE,YAAY,GAAE,OAAuB,GAAG,SAAS,EAAE,CAY/F;AACD,uDAAuD;AACvD,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAQjE;AACD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,QAAQ,GAAG,WAAW,EAAE,CAiBnE;AACD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,YAAY,EAAE,MAAM,GAAG;IACzE,SAAS,EAAE,YAAY,CAAC;IACxB,QAAQ,EAAE,YAAY,CAAC;IACvB,SAAS,EAAE,YAAY,CAAC;CAC3B,CAsBJ;AACD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAE,MAAW,EAAE,YAAY,CAAC,EAAE,OAAO,GAAG,cAAc,CA8C/H"}