brep-io-kernel 1.0.0

package/src/UI/featureDialogWidgets/threadDesignationField.js

@@ -0,0 +1,160 @@
+import { getThreadDesignationOptions, normalizeThreadStandard } from '../../features/hole/threadDesignationCatalog.js';
+
+const CUSTOM_VALUE = '__custom__';
+
+export function renderThreadDesignationField({ ui, key, def, id }) {
+    const wrap = document.createElement('div');
+    wrap.className = 'thread-designation-field';
+    wrap.dataset.role = 'thread-designation-wrap';
+
+    const select = document.createElement('select');
+    select.id = id;
+    select.className = 'select';
+    select.dataset.role = 'thread-designation';
+    wrap.appendChild(select);
+
+    const customInput = document.createElement('input');
+    customInput.type = 'text';
+    customInput.className = 'input';
+    customInput.dataset.role = 'thread-designation-custom';
+    customInput.placeholder = def?.hint || 'Enter thread designation';
+    customInput.style.display = 'none';
+    customInput.style.marginTop = '6px';
+    wrap.appendChild(customInput);
+
+    const standardKey = def?.standardField || 'threadStandard';
+    const getStandard = () => normalizeThreadStandard(ui?.params?.[standardKey] || 'NONE');
+    let lastStandard = getStandard();
+    let lastValue = ui.params[key] ?? ui._pickInitialValue(key, def);
+
+    const setValue = (value, emit = true) => {
+        const next = value == null ? '' : String(value);
+        ui.params[key] = next;
+        if (emit && next !== lastValue) {
+            lastValue = next;
+            ui._emitParamsChange(key, next);
+        } else {
+            lastValue = next;
+        }
+    };
+
+    const toggleCustom = (show) => {
+        customInput.style.display = show ? 'block' : 'none';
+    };
+
+    const buildOptions = (std) => {
+        const options = getThreadDesignationOptions(std);
+        select.textContent = '';
+        if (options.length) {
+            for (const opt of options) {
+                const el = document.createElement('option');
+                el.value = opt.value;
+                el.textContent = opt.label || opt.value;
+                select.appendChild(el);
+            }
+            const customOpt = document.createElement('option');
+            customOpt.value = CUSTOM_VALUE;
+            customOpt.textContent = 'Custom...';
+            select.appendChild(customOpt);
+        } else {
+            const customOpt = document.createElement('option');
+            customOpt.value = CUSTOM_VALUE;
+            customOpt.textContent = std === 'NONE'
+                ? 'Select a thread standard or type custom'
+                : 'Custom designation';
+            select.appendChild(customOpt);
+        }
+        return options;
+    };
+
+    const syncSelection = (emit = false, preferPreset = false) => {
+        const std = getStandard();
+        lastStandard = std;
+        const options = buildOptions(std);
+        const current = ui.params[key] ?? ui._pickInitialValue(key, def);
+        const match = options.find((o) => o.value === current);
+        if (match) {
+            select.value = match.value;
+            toggleCustom(false);
+            setValue(match.value, emit);
+            return;
+        }
+        if ((preferPreset || !current) && options.length) {
+            const fallback = options[0];
+            select.value = fallback.value;
+            toggleCustom(false);
+            setValue(fallback.value, emit);
+            return;
+        }
+        select.value = CUSTOM_VALUE;
+        toggleCustom(true);
+        customInput.value = current || customInput.value || '';
+        setValue(customInput.value, emit);
+    };
+
+    const handleSelectChange = () => {
+        if (select.value === CUSTOM_VALUE) {
+            toggleCustom(true);
+            setValue(customInput.value || '', true);
+            customInput.focus();
+        } else {
+            toggleCustom(false);
+            setValue(select.value, true);
+        }
+    };
+
+    const handleCustomInput = () => {
+        setValue(customInput.value, false);
+    };
+
+    const handleCustomCommit = () => {
+        setValue(customInput.value, true);
+    };
+
+    select.addEventListener('change', handleSelectChange);
+    customInput.addEventListener('input', handleCustomInput);
+    customInput.addEventListener('change', handleCustomCommit);
+    customInput.addEventListener('blur', handleCustomCommit);
+
+    let cleanupStandardListener = null;
+    const standardInput = ui?._inputs?.get?.(standardKey);
+    if (standardInput && typeof standardInput.addEventListener === 'function') {
+        const onStandardChange = () => {
+            const nextStd = getStandard();
+            const shouldEmit = nextStd !== lastStandard;
+            syncSelection(shouldEmit, true);
+        };
+        standardInput.addEventListener('change', onStandardChange);
+        cleanupStandardListener = () => standardInput.removeEventListener('change', onStandardChange);
+    }
+
+    syncSelection(false);
+
+    return {
+        inputEl: wrap,
+        inputRegistered: true,
+        skipDefaultRefresh: true,
+        activate() {
+            if (select.value === CUSTOM_VALUE) {
+                customInput.focus();
+            } else {
+                select.focus();
+            }
+        },
+        readValue() {
+            return ui.params[key];
+        },
+        refreshFromParams(value) {
+            if (value !== undefined) ui.params[key] = value;
+            const stdChanged = getStandard() !== lastStandard;
+            syncSelection(false, stdChanged);
+        },
+        destroy() {
+            if (cleanupStandardListener) cleanupStandardListener();
+            select.removeEventListener('change', handleSelectChange);
+            customInput.removeEventListener('input', handleCustomInput);
+            customInput.removeEventListener('change', handleCustomCommit);
+            customInput.removeEventListener('blur', handleCustomCommit);
+        },
+    };
+}

package/src/UI/featureDialogWidgets/transformField.js

@@ -0,0 +1,252 @@
+import * as THREE from 'three';
+import { combineBaseWithDeltaDeg } from '../../utils/xformMath.js';
+
+export function renderTransformField({ ui, key, def, id, controlWrap, valueAdapter = null }) {
+    const inputEl = document.createElement('input');
+    inputEl.type = 'hidden';
+    inputEl.id = id;
+
+    const wrap = document.createElement('div');
+    wrap.className = 'transform-wrap';
+
+    const adapter = (valueAdapter && typeof valueAdapter === 'object') ? valueAdapter : null;
+    const activationKey = (adapter && typeof adapter.activationKey === 'string') ? adapter.activationKey : key;
+    const clone3 = (arr, fallback) => {
+        const copy = Array.isArray(arr) ? arr.slice(0, 3) : [];
+        while (copy.length < 3) copy.push(fallback);
+        return copy;
+    };
+    const sanitizeTRS = (raw) => {
+        const obj = (raw && typeof raw === 'object') ? raw : {};
+        return {
+            position: clone3(obj.position, 0),
+            rotationEuler: clone3(obj.rotationEuler, 0),
+            scale: clone3(obj.scale, 1),
+        };
+    };
+    const readTRS = () => {
+        if (adapter && typeof adapter.get === 'function') {
+            try { return sanitizeTRS(adapter.get()); } catch (_) { return sanitizeTRS(null); }
+        }
+        return sanitizeTRS(ui._pickInitialValue(key, def));
+    };
+    const writeTRS = (next) => {
+        const sanitized = sanitizeTRS(next);
+        if (adapter && typeof adapter.set === 'function') {
+            try {
+                adapter.set({
+                    position: sanitized.position.slice(0, 3),
+                    rotationEuler: sanitized.rotationEuler.slice(0, 3),
+                    scale: sanitized.scale.slice(0, 3),
+                });
+            } catch (_) { /* ignore adapter errors */ }
+        } else {
+            ui.params[key] = {
+                position: sanitized.position.slice(0, 3),
+                rotationEuler: sanitized.rotationEuler.slice(0, 3),
+                scale: sanitized.scale.slice(0, 3),
+            };
+        }
+        return sanitized;
+    };
+    const emitChange = (value) => {
+        if (adapter && typeof adapter.emit === 'function') {
+            try { adapter.emit(value); return; } catch (_) { return; }
+        }
+        ui._emitParamsChange(activationKey, value);
+    };
+
+    const btn = document.createElement('button');
+    btn.type = 'button';
+    btn.className = 'btn';
+    btn.textContent = String(def.label || 'Position in 3D…');
+
+    const info = document.createElement('div');
+    info.className = 'transform-info';
+    const fmt = (n) => {
+        const v = Number(n);
+        if (!Number.isFinite(v)) return '0';
+        const a = Math.abs(v);
+        const prec = a >= 100 ? 0 : (a >= 10 ? 1 : 2);
+        return String(v.toFixed(prec));
+    };
+    const updateInfo = (value = null) => {
+        const v = value ? sanitizeTRS(value) : readTRS();
+        const p = Array.isArray(v.position) ? v.position : [0, 0, 0];
+        const r = Array.isArray(v.rotationEuler) ? v.rotationEuler : [0, 0, 0];
+        info.textContent = `pos(${fmt(p[0])}, ${fmt(p[1])}, ${fmt(p[2])})  rot(${fmt(r[0])}, ${fmt(r[1])}, ${fmt(r[2])})`;
+    };
+    updateInfo();
+
+    const modes = document.createElement('div');
+    modes.className = 'transform-modes';
+
+    const getTRS = () => readTRS();
+    const setTRS = (next, applyTarget = true, options = {}) => {
+        const { skipWrite = false } = options;
+        const sanitized = skipWrite ? sanitizeTRS(next) : writeTRS(next);
+        try { updateInfo(sanitized); } catch (_) {}
+        try {
+            const row = ui._fieldsWrap.querySelector(`[data-key="${key}"]`);
+            const scope = row || wrap;
+            const map = [
+                ['.tf-pos-x', sanitized.position[0]],
+                ['.tf-pos-y', sanitized.position[1]],
+                ['.tf-pos-z', sanitized.position[2]],
+                ['.tf-rot-x', sanitized.rotationEuler[0]],
+                ['.tf-rot-y', sanitized.rotationEuler[1]],
+                ['.tf-rot-z', sanitized.rotationEuler[2]],
+            ];
+            for (const [sel, val] of map) {
+                const el = scope ? scope.querySelector(sel) : null;
+                if (el) ui._setInputValue(el, 'number', val);
+            }
+        } catch (_) {}
+        if (applyTarget) {
+            try {
+                const active = ui.activeTransform;
+                if (active && active.inputEl === inputEl && active.target) {
+                    const base = active.baseTransform || { position: [0,0,0], quaternion: [0,0,0,1], scale: [1,1,1] };
+                    const Mabs = combineBaseWithDeltaDeg(base, sanitized, THREE);
+                    const pos = new THREE.Vector3();
+                    const quat = new THREE.Quaternion();
+                    const scl = new THREE.Vector3();
+                    Mabs.decompose(pos, quat, scl);
+                    active.target.position.copy(pos);
+                    active.target.quaternion.copy(quat);
+                    active.target.scale.copy(scl);
+                }
+            } catch (_) { }
+        }
+        return sanitized;
+    };
+
+    const grid = document.createElement('div');
+    grid.className = 'transform-grid';
+    const addRow = (labelTxt, clsPrefix, valuesArr) => {
+        const rowEl = document.createElement('div');
+        rowEl.className = 'transform-row';
+        const lab = document.createElement('div');
+        lab.className = 'transform-label';
+        lab.textContent = labelTxt;
+        const inputs = document.createElement('div');
+        inputs.className = 'transform-inputs';
+        const axes = ['x', 'y', 'z'];
+        for (let i = 0; i < 3; i++) {
+            const inp = document.createElement('input');
+            inp.className = 'input transform-input ' + `tf-${clsPrefix}-${axes[i]}`;
+            inp.type = 'number';
+            inp.step = 'any';
+            ui._setInputValue(inp, 'number', valuesArr[i] ?? 0);
+            const numericPatternLocal = /^-?\d*\.?\d*$/;
+            const isNumericLikeLocal = (value) => {
+                if (value === '' || value == null) return true;
+                return numericPatternLocal.test(String(value));
+            };
+            const onFocusToggleTypeLocal = (el) => {
+                try {
+                    if (isNumericLikeLocal(el.value)) {
+                        el.type = 'number';
+                    } else {
+                        el.type = 'text';
+                    }
+                } catch (_) { }
+            };
+            inp.addEventListener('focus', () => {
+                onFocusToggleTypeLocal(inp);
+                ui._stopActiveReferenceSelection();
+            });
+            inp.addEventListener('beforeinput', (e) => {
+                try {
+                    const nextVal = String(inp.value || '') + String(e.data || '');
+                    if (!isNumericLikeLocal(nextVal)) {
+                        if (inp.type !== 'text') inp.type = 'text';
+                    } else if (inp.type !== 'number') {
+                        inp.type = 'number';
+                    }
+                } catch (_) { }
+            });
+            inp.addEventListener('change', () => {
+                const cur = getTRS();
+                const val = inp.value;
+                if (clsPrefix === 'pos') cur.position[i] = val;
+                else cur.rotationEuler[i] = val;
+                const updated = setTRS(cur, true);
+                emitChange(updated);
+            });
+            inputs.appendChild(inp);
+        }
+        rowEl.appendChild(lab);
+        rowEl.appendChild(inputs);
+        grid.appendChild(rowEl);
+    };
+    const curTRS = getTRS();
+    addRow('Position', 'pos', curTRS.position);
+    addRow('Rotation (deg)', 'rot', curTRS.rotationEuler);
+
+    const resetBtn = document.createElement('button');
+    resetBtn.type = 'button';
+    resetBtn.className = 'btn btn-slim';
+    resetBtn.textContent = 'Reset';
+    resetBtn.title = 'Reset translation and rotation to 0';
+    resetBtn.addEventListener('click', () => {
+        const cur = getTRS();
+        const next = { position: [0, 0, 0], rotationEuler: [0, 0, 0], scale: cur.scale };
+        const updated = setTRS(next, true);
+        emitChange(updated);
+        const featureID = (ui.params && Object.prototype.hasOwnProperty.call(ui.params, 'featureID'))
+            ? ui.params.featureID
+            : (ui.params?.id ?? null);
+        if (typeof ui.options.onChange === 'function') ui.options.onChange(featureID);
+    });
+    modes.appendChild(resetBtn);
+
+    const buildTransformAdapter = () => {
+        if (!adapter) return null;
+        const wrapper = {};
+        if (typeof adapter.stepId === 'string') wrapper.stepId = adapter.stepId;
+        wrapper.get = () => {
+            if (typeof adapter.get === 'function') {
+                try { return sanitizeTRS(adapter.get()); } catch (_) { return readTRS(); }
+            }
+            return readTRS();
+        };
+        wrapper.set = (value) => {
+            const sanitized = sanitizeTRS(value);
+            if (typeof adapter.set === 'function') {
+                try { adapter.set(sanitized); } catch (_) { }
+                setTRS(sanitized, true, { skipWrite: true });
+            } else {
+                setTRS(sanitized, true);
+            }
+            emitChange(sanitized);
+        };
+        if (typeof adapter.getBase === 'function') {
+            wrapper.getBase = () => {
+                try { return adapter.getBase(); } catch (_) { return null; }
+            };
+        }
+        return wrapper;
+    };
+    const transformValueAdapter = buildTransformAdapter();
+    const activate = () => ui._activateTransformWidget({ inputEl, wrapEl: wrap, key: activationKey, def, valueAdapter: transformValueAdapter });
+    btn.addEventListener('click', activate);
+
+    wrap.appendChild(btn);
+    const details = document.createElement('div');
+    details.className = 'transform-details';
+    details.appendChild(modes);
+    details.appendChild(grid);
+    details.appendChild(info);
+    wrap.appendChild(details);
+    wrap.appendChild(inputEl);
+    controlWrap.appendChild(wrap);
+
+    return {
+        inputEl,
+        activate,
+        readValue() {
+            return readTRS();
+        },
+    };
+}

package/src/UI/featureDialogWidgets/utils.js

@@ -0,0 +1,43 @@
+export function normalizeReferenceName(value) {
+    if (value == null) return null;
+
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed) return null;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === 'object') {
+                const parsedName = typeof parsed.name === 'string' ? parsed.name.trim() : '';
+                if (parsedName) return parsedName;
+                const parsedId = typeof parsed.id === 'string' ? parsed.id.trim() : '';
+                if (parsedId) return parsedId;
+            }
+        } catch (_) { /* not JSON */ }
+        return trimmed;
+    }
+
+    if (typeof value === 'object') {
+        if (typeof value.name === 'string' && value.name.trim()) return value.name.trim();
+        if (typeof value.id === 'string' && value.id.trim()) return value.id.trim();
+        if (Array.isArray(value.path)) {
+            const joined = value.path.filter(Boolean).map(String).join(' › ');
+            if (joined) return joined;
+        }
+    }
+
+    const asString = String(value);
+    return asString.trim() || null;
+}
+
+export function normalizeReferenceList(values) {
+    if (!Array.isArray(values)) return [];
+    const seen = new Set();
+    const out = [];
+    for (const item of values) {
+        const normalized = normalizeReferenceName(item);
+        if (!normalized || seen.has(normalized)) continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}

package/src/UI/featureDialogWidgets/vec3Field.js

@@ -0,0 +1,133 @@
+export function renderVec3Field({ ui, key, def }) {
+    const inputEl = document.createElement('div');
+    inputEl.className = 'transform-grid';
+
+    const showUniform = Boolean(def && (def.uniformToggle === true));
+    let uniformChecked = Boolean(def && (def.uniformDefault === true));
+    let uniformCb = null;
+    if (showUniform) {
+        const uniformWrap = document.createElement('div');
+        uniformWrap.className = 'transform-row';
+        const spacer = document.createElement('div');
+        spacer.className = 'transform-label';
+        spacer.textContent = '';
+        const controls = document.createElement('div');
+        controls.className = 'transform-inputs';
+        const cbLabel = document.createElement('label');
+        cbLabel.style.display = 'inline-flex';
+        cbLabel.style.alignItems = 'center';
+        cbLabel.style.gap = '6px';
+        uniformCb = document.createElement('input');
+        uniformCb.type = 'checkbox';
+        uniformCb.checked = uniformChecked;
+        const txt = document.createElement('span');
+        txt.textContent = String(def.uniformLockLabel || 'Uniform');
+        cbLabel.appendChild(uniformCb);
+        cbLabel.appendChild(txt);
+        controls.appendChild(cbLabel);
+        uniformWrap.appendChild(spacer);
+        uniformWrap.appendChild(controls);
+        inputEl.appendChild(uniformWrap);
+    }
+
+    const mkRow = (labelText) => {
+        const rowEl = document.createElement('div');
+        rowEl.className = 'transform-row';
+        const lab = document.createElement('div');
+        lab.className = 'transform-label';
+        lab.textContent = labelText;
+        const inputsWrap = document.createElement('div');
+        inputsWrap.className = 'transform-inputs';
+        rowEl.appendChild(lab);
+        rowEl.appendChild(inputsWrap);
+        return { rowEl, inputsWrap };
+    };
+
+    const { rowEl, inputsWrap } = mkRow('XYZ');
+    inputEl.appendChild(rowEl);
+
+    const valuesArr = (() => {
+        const v = ui._pickInitialValue(key, def);
+        if (Array.isArray(v)) return [v[0] ?? 0, v[1] ?? 0, v[2] ?? 0];
+        if (v && typeof v === 'object') return [v.x ?? 0, v.y ?? 0, v.z ?? 0];
+        return [0, 0, 0];
+    })();
+
+    const stepStr = (def && (def.step != null)) ? String(def.step) : 'any';
+
+    const setParamFromInputs = () => {
+        const inps = Array.from(inputsWrap.querySelectorAll('input'));
+        const arr = inps.map((el) => el.value);
+        ui.params[key] = [arr[0], arr[1], arr[2]];
+        ui._emitParamsChange(key, ui.params[key]);
+    };
+
+    const inputs = [];
+    const numericPattern = /^-?\d*\.?\d*$/;
+    const isNumericLike = (value) => {
+        if (value === '' || value == null) return true;
+        return numericPattern.test(String(value));
+    };
+    const toggleTypeForContent = (el) => {
+        try {
+            if (isNumericLike(el.value)) el.type = 'number';
+            else el.type = 'text';
+        } catch (_) { }
+    };
+
+    for (let i = 0; i < 3; i++) {
+        const inp = document.createElement('input');
+        inp.type = 'number';
+        inp.className = 'input transform-input';
+        inp.step = stepStr;
+        ui._setInputValue(inp, 'number', valuesArr[i] ?? 0);
+        inp.addEventListener('focus', () => toggleTypeForContent(inp));
+        inp.addEventListener('beforeinput', (e) => {
+            try {
+                const nextVal = String(inp.value || '') + String(e.data || '');
+                if (!isNumericLike(nextVal)) {
+                    if (inp.type !== 'text') inp.type = 'text';
+                } else if (inp.type !== 'number') {
+                    inp.type = 'number';
+                }
+            } catch (_) { }
+        });
+        inp.addEventListener('change', () => {
+            if (showUniform && uniformCb && uniformCb.checked) {
+                const v = inp.value;
+                for (const other of inputsWrap.querySelectorAll('input')) other.value = v;
+            }
+            setParamFromInputs();
+        });
+        inputsWrap.appendChild(inp);
+        inputs.push(inp);
+    }
+
+    if (showUniform && uniformCb) {
+        const enforceUniformNow = () => {
+            if (uniformCb.checked && inputs.length) {
+                const v = inputs[0].value;
+                for (let i = 0; i < inputs.length; i++) inputs[i].value = String(v);
+                setParamFromInputs();
+            }
+        };
+        uniformCb.addEventListener('change', () => enforceUniformNow());
+        if (uniformChecked) enforceUniformNow();
+    }
+
+    return {
+        inputEl,
+        activate() {
+            const first = inputEl.querySelector('input');
+            if (first) first.focus();
+        },
+        readValue() {
+            const current = ui.params[key];
+            if (Array.isArray(current)) return current.slice(0, 3);
+            if (current && typeof current === 'object') {
+                return [current.x ?? 0, current.y ?? 0, current.z ?? 0];
+            }
+            return [0, 0, 0];
+        },
+    };
+}