brep-io-kernel 1.0.0-ci.10

package/src/UI/dialogs.js

@@ -0,0 +1,351 @@
+
+const overlayStyle = {
+    position: 'fixed',
+    inset: '0',
+    background: 'rgba(0,0,0,.6)',
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+    zIndex: '10000',
+};
+
+const dialogStyle = {
+    // Centered within overlay
+    position: 'relative',
+    background: 'var(--bg-elev, #12141b)',
+    color: 'var(--text, #e6e6e6)',
+    padding: '14px',
+    boxShadow: '0 10px 40px rgba(0,0,0,.5)',
+    borderRadius: '12px',
+    border: '1px solid var(--border, #262b36)',
+    fontSize: '14px',
+    lineHeight: '1.4',
+    textAlign: 'left',
+    width: 'min(480px, calc(100vw - 32px))',
+    maxWidth: '100%',
+};
+
+// Buttons follow the app's neutral button style; the "confirm" style is the emphasized/primary look.
+const neutralButtonStyle = {
+    //appearance: 'none',
+    border: '1px solid var(--border, #262b36)',
+    background: 'linear-gradient(180deg, rgba(255,255,255,.06), rgba(255,255,255,.03))',
+    color: 'var(--text, #e6e6e6)',
+    borderRadius: '10px',
+    padding: '8px 12px',
+    fontWeight: '700',
+    fontSize: '12px',
+    cursor: 'pointer',
+};
+
+const emphasizedButtonStyle = {
+    ...neutralButtonStyle,
+    border: '1px solid var(--focus, #3b82f6)',
+    boxShadow: '0 0 0 3px rgba(59,130,246,.15)'
+};
+
+// Keep variable names used below; map to our neutral/emphasized styles.
+const confirmButtonStyle = emphasizedButtonStyle;   // used for the default/emphasized action
+const cancelButtonStyle = neutralButtonStyle;       // used for the secondary action
+
+let _dialogOpenCount = 0;
+const markDialogOpen = () => {
+    _dialogOpenCount += 1;
+    window.__BREPDialogOpen = _dialogOpenCount > 0;
+};
+const markDialogClosed = () => {
+    _dialogOpenCount = Math.max(0, _dialogOpenCount - 1);
+    window.__BREPDialogOpen = _dialogOpenCount > 0;
+};
+window.isDialogOpen = () => _dialogOpenCount > 0;
+
+
+window.confirm = async (message, timeoutInSeconds = null, defaultValue = true) => {
+    return new Promise((resolve) => {
+        markDialogOpen();
+        const overlay = document.createElement('div');
+        const dialog = document.createElement('div');
+        const messageDiv = document.createElement('div');
+        const countdownDiv = document.createElement('div');
+        const buttonContainer = document.createElement('div');
+        const confirmButton = document.createElement('button');
+        const cancelButton = document.createElement('button');
+
+        // Overlay + dialog styles
+        Object.assign(overlay.style, overlayStyle);
+        Object.assign(dialog.style, dialogStyle);
+
+        messageDiv.textContent = message;
+        // preformatted text and spacing
+        messageDiv.style.whiteSpace = 'pre-wrap';
+        messageDiv.style.marginBottom = '8px';
+        messageDiv.style.color = 'var(--text, #e6e6e6)';
+
+        // Countdown indicator
+        if (timeoutInSeconds && timeoutInSeconds > 0) {
+            countdownDiv.textContent = `Time remaining: ${timeoutInSeconds} seconds`;
+            countdownDiv.style.marginBottom = '8px';
+            countdownDiv.style.fontSize = '12px';
+            countdownDiv.style.color = 'var(--muted, #9aa4b2)';
+            dialog.appendChild(countdownDiv);
+        }
+
+        confirmButton.textContent = 'Yes';
+        cancelButton.textContent = 'No';
+
+
+        // Highlight default button
+        const defaultButton = defaultValue ? confirmButton : cancelButton;
+        if (defaultValue) {
+            Object.assign(confirmButton.style, confirmButtonStyle);
+            Object.assign(cancelButton.style, cancelButtonStyle);
+        } else {
+            Object.assign(confirmButton.style, cancelButtonStyle);
+            Object.assign(cancelButton.style, confirmButtonStyle);
+        }
+
+        // Button container styling
+        buttonContainer.style.display = 'flex';
+        buttonContainer.style.justifyContent = 'flex-end';
+        buttonContainer.style.gap = '8px';
+        buttonContainer.style.marginTop = '12px';
+
+        buttonContainer.appendChild(confirmButton);
+        buttonContainer.appendChild(cancelButton);
+
+        dialog.appendChild(messageDiv);
+        dialog.appendChild(buttonContainer);
+        overlay.appendChild(dialog);
+        document.body.appendChild(overlay);
+
+        let timeout = null;
+        let countdownInterval = null;
+
+        if (timeoutInSeconds && timeoutInSeconds > 0) {
+            timeout = setTimeout(() => {
+                cleanup();
+                resolve(defaultValue);
+            }, timeoutInSeconds * 1000);
+
+            // Update countdown every second
+            let remainingTime = timeoutInSeconds;
+            countdownInterval = setInterval(() => {
+                remainingTime -= 1;
+                if (remainingTime <= 0) {
+                    clearInterval(countdownInterval);
+                }
+                countdownDiv.textContent = `Time remaining: ${remainingTime} seconds`;
+            }, 1000);
+        }
+
+        const cleanup = () => {
+            if (timeout) clearTimeout(timeout); // Clear the timeout if it exists
+            if (countdownInterval) clearInterval(countdownInterval); // Clear the countdown interval
+            confirmButton.removeEventListener('click', onConfirm);
+            cancelButton.removeEventListener('click', onCancel);
+            try { overlay.remove(); } catch (_) { try { dialog.remove(); } catch (_) {} }
+            markDialogClosed();
+        };
+
+        const onConfirm = () => {
+            cleanup(); // Ensure dialog is removed first
+            resolve(true); // Then resolve the promise
+        };
+
+        const onCancel = () => {
+            cleanup(); // Ensure dialog is removed first
+            resolve(false); // Then resolve the promise
+        };
+
+        confirmButton.addEventListener('click', onConfirm);
+        cancelButton.addEventListener('click', onCancel);
+
+        // ensure the emphasized/default action receives focus for Enter/Space
+        requestAnimationFrame(() => defaultButton.focus());
+    });
+};
+
+
+
+
+window.alert = async (message, timeoutInSeconds = null) => {
+    return new Promise((resolve) => {
+        markDialogOpen();
+        const overlay = document.createElement('div');
+        const dialog = document.createElement('div');
+        const messageDiv = document.createElement('div');
+        const countdownDiv = document.createElement('div');
+        const buttonContainer = document.createElement('div');
+        const okButton = document.createElement('button');
+
+        // Set up styles
+        Object.assign(overlay.style, overlayStyle);
+        Object.assign(dialog.style, dialogStyle);
+
+        messageDiv.textContent = message;
+        // set style to preformatted text
+        messageDiv.style.whiteSpace = 'pre-wrap';
+        messageDiv.style.marginBottom = '8px';
+        messageDiv.style.color = 'var(--text, #e6e6e6)';
+
+        // Countdown indicator
+        if (timeoutInSeconds && timeoutInSeconds > 0) {
+            countdownDiv.textContent = `Time remaining: ${timeoutInSeconds} seconds`;
+            countdownDiv.style.marginBottom = '8px';
+            countdownDiv.style.fontSize = '12px';
+            countdownDiv.style.color = 'var(--muted, #9aa4b2)';
+            dialog.appendChild(countdownDiv);
+        }
+
+        okButton.textContent = 'OK';
+        Object.assign(okButton.style, confirmButtonStyle);
+
+        // Button container styling
+        buttonContainer.style.display = 'flex';
+        buttonContainer.style.justifyContent = 'flex-end';
+        buttonContainer.style.gap = '8px';
+        buttonContainer.style.marginTop = '12px';
+
+        buttonContainer.appendChild(okButton);
+
+        dialog.appendChild(messageDiv);
+        dialog.appendChild(buttonContainer);
+        overlay.appendChild(dialog);
+        document.body.appendChild(overlay);
+
+        let timeout = null;
+        let countdownInterval = null;
+
+        if (timeoutInSeconds && timeoutInSeconds > 0) {
+            timeout = setTimeout(() => {
+                cleanup();
+                resolve();
+            }, timeoutInSeconds * 1000);
+
+            // Update countdown every second
+            let remainingTime = timeoutInSeconds;
+            countdownInterval = setInterval(() => {
+                remainingTime -= 1;
+                if (remainingTime <= 0) {
+                    clearInterval(countdownInterval);
+                }
+                countdownDiv.textContent = `Time remaining: ${remainingTime} seconds`;
+            }, 1000);
+        }
+
+        const cleanup = () => {
+            if (timeout) clearTimeout(timeout); // Clear the timeout if it exists
+            if (countdownInterval) clearInterval(countdownInterval); // Clear the countdown interval
+            okButton.removeEventListener('click', onOk);
+            try { overlay.remove(); } catch (_) { try { dialog.remove(); } catch (_) {} }
+            markDialogClosed();
+        };
+
+        const onOk = () => {
+            cleanup(); // Ensure dialog is removed first
+            resolve(); // Then resolve the promise
+        };
+
+        okButton.addEventListener('click', onOk);
+
+        // make the OK button focused by default
+        okButton.focus();
+
+    });
+};
+
+
+
+
+window.prompt = async (message, defaultValue = '') => {
+    return new Promise((resolve) => {
+        markDialogOpen();
+        const overlay = document.createElement('div');
+        const dialog = document.createElement('div');
+        const messageDiv = document.createElement('div');
+        const inputField = document.createElement('input');
+        const buttonContainer = document.createElement('div');
+        const okButton = document.createElement('button');
+        const cancelButton = document.createElement('button');
+
+        // Set up styles
+        Object.assign(overlay.style, overlayStyle);
+        Object.assign(dialog.style, dialogStyle);
+
+        messageDiv.textContent = message;
+        messageDiv.style.whiteSpace = 'pre-wrap';
+        messageDiv.style.marginBottom = '8px';
+        messageDiv.style.color = 'var(--text, #e6e6e6)';
+
+        inputField.type = 'text';
+        inputField.value = defaultValue;
+        inputField.style.width = '100%';
+        inputField.style.boxSizing = 'border-box';
+        inputField.style.padding = '8px 10px';
+        inputField.style.border = '1px solid var(--border, #262b36)';
+        inputField.style.borderRadius = '10px';
+        inputField.style.marginBottom = '10px';
+        inputField.style.fontSize = '14px';
+        inputField.style.background = 'var(--input-bg, #0b0e14)';
+        inputField.style.color = 'var(--text, #e6e6e6)';
+        inputField.style.outline = 'none';
+
+        okButton.textContent = 'OK';
+        Object.assign(okButton.style, confirmButtonStyle);
+        cancelButton.textContent = 'Cancel';
+        Object.assign(cancelButton.style, cancelButtonStyle);
+
+        buttonContainer.appendChild(okButton);
+        buttonContainer.appendChild(cancelButton);
+
+        // Button container styling
+        buttonContainer.style.display = 'flex';
+        buttonContainer.style.justifyContent = 'flex-end';
+        buttonContainer.style.gap = '8px';
+        buttonContainer.style.marginTop = '4px';
+
+        dialog.appendChild(messageDiv);
+        dialog.appendChild(inputField);
+        dialog.appendChild(buttonContainer);
+        overlay.appendChild(dialog);
+        document.body.appendChild(overlay);
+
+        // Focus and select the existing text so typing replaces it by default.
+        requestAnimationFrame(() => {
+            inputField.focus();
+            inputField.select();
+        });
+
+        const cleanup = () => {
+            okButton.removeEventListener('click', onOk);
+            cancelButton.removeEventListener('click', onCancel);
+            inputField.removeEventListener('keydown', onEnter);
+            try { overlay.remove(); } catch (_) { try { dialog.remove(); } catch (_) {} }
+            markDialogClosed();
+        };
+
+        const onOk = () => {
+            cleanup();
+            resolve(inputField.value); // Resolve with the value entered
+        };
+
+        const onCancel = () => {
+            cleanup();
+            resolve(null); // Resolve with null for cancel
+        };
+
+        const onEnter = (event) => {
+            if (event.key === 'Enter') {
+                event.preventDefault();
+                onOk();
+            } else if (event.key === 'Escape') {
+                event.preventDefault();
+                onCancel();
+            }
+        };
+
+        okButton.addEventListener('click', onOk);
+        cancelButton.addEventListener('click', onCancel);
+        inputField.addEventListener('keydown', onEnter);
+    });
+};

package/src/UI/expressionsManager.js

@@ -0,0 +1,100 @@
+// This is a simple widget that contains a text area.
+// The text area is going to have javascript code
+
+
+
+export class expressionsManager {
+    constructor(viewer) {
+        this.viewer = viewer;
+        this.uiElement = document.createElement('div');
+        this.expressionCode = '';
+        this.generateUI();
+    }
+
+    generateUI() {
+        // add a style element with the styles
+        const style = document.createElement('style');
+        style.textContent = `
+            .test-expressions-button {
+                background: rgb(31, 41, 55);
+                color: rgb(249, 250, 251);
+                border: 1px solid rgb(55, 65, 81);
+                padding: 3px;
+                border-radius: 8px;
+                cursor: pointer;
+                font-weight: 700;
+                outline: none;
+                transition: background 120ms, transform 60ms, box-shadow 120ms;
+                user-select: none;
+                box-shadow: none;
+                transform: none;
+            }
+            .test-expressions-button:hover {
+                background-color: #45a049;
+            }
+            .expressions-textarea {
+                width: 100%;
+                height: 200px;
+                font-family: monospace;
+                padding: 5px;
+            }
+            .expressions-results {
+                margin-top: 10px;
+                font-weight: bold;
+                padding: 5px;
+                color: red;
+            }
+        `;
+        document.head.appendChild(style);
+
+        const textArea = document.createElement('textarea');
+        textArea.placeholder = `// example Javascript math syntax . . .\nx = 30;\ny = 2 * x;`;
+        this.uiElement.appendChild(textArea);
+        this.textArea = textArea;
+        this.textArea.classList.add('expressions-textarea');
+        textArea.value = this.viewer.partHistory.expressions;
+        this.textArea.addEventListener('change', () => this.saveAndTest());
+        this.uiElement.appendChild(this.textArea);
+
+        // add a button that can trigger the save and test method
+        this.saveButton = document.createElement('button');
+        this.saveButton.textContent = 'Test Expressions';
+        this.saveButton.classList.add('test-expressions-button');
+        this.saveButton.addEventListener('click', () => this.saveAndTest());
+        this.uiElement.appendChild(this.saveButton);
+
+
+        this.resultDiv = document.createElement('div');
+        this.resultDiv.classList.add('expressions-results');
+        this.uiElement.appendChild(this.resultDiv);
+    }
+
+    saveAndTest() {
+        this.resultDiv.textContent = "Expressions evaluated successfully.";
+        this.resultDiv.style.color = 'green';
+        let succeeded = false;
+        try {
+            const functionString = `return (function(){ ${this.textArea.value} ;});`;
+            Function(functionString)();
+            this.viewer.partHistory.expressions = this.textArea.value;
+            succeeded = true;
+        } catch (error) {
+            this.resultDiv.innerHTML = "Error occurred while testing expressions. <br>" + error.message;
+            this.resultDiv.style.color = 'red';
+            succeeded = false;
+        }
+
+        if (succeeded) {
+            this.resultDiv.textContent = "Expressions evaluated successfully.";
+            this.resultDiv.style.color = 'green';
+            const runPromise = this.viewer.partHistory.runHistory();
+            if (runPromise && typeof runPromise.then === 'function') {
+                runPromise.then(() => {
+                    this.viewer.partHistory?.queueHistorySnapshot?.({ reason: 'expressions' });
+                });
+            } else {
+                this.viewer.partHistory?.queueHistorySnapshot?.({ reason: 'expressions' });
+            }
+        }
+    }
+}

package/src/UI/featureDialogWidgets/booleanField.js

@@ -0,0 +1,25 @@
+export function renderBooleanField({ ui, key, def, id }) {
+    const inputEl = document.createElement('input');
+    inputEl.type = 'checkbox';
+    inputEl.id = id;
+    inputEl.className = 'checkbox';
+
+    ui._setInputValue(inputEl, 'boolean', ui._pickInitialValue(key, def));
+
+    inputEl.addEventListener('change', () => {
+        const v = Boolean(inputEl.checked);
+        ui.params[key] = v;
+        ui._emitParamsChange(key, v);
+        ui._stopActiveReferenceSelection();
+    });
+
+    return {
+        inputEl,
+        activate() {
+            inputEl.focus();
+        },
+        readValue() {
+            return Boolean(inputEl.checked);
+        },
+    };
+}

package/src/UI/featureDialogWidgets/booleanOperationField.js

@@ -0,0 +1,97 @@
+export function renderBooleanOperationField({ ui, key, def, controlWrap }) {
+    if (!ui.params[key] || typeof ui.params[key] !== 'object') {
+        ui.params[key] = { targets: [], operation: 'NONE', operation: 'NONE' };
+    } else {
+        if (!Array.isArray(ui.params[key].targets)) ui.params[key].targets = [];
+        if (!ui.params[key].operation && !ui.params[key].operation) ui.params[key].operation = 'NONE';
+    }
+
+    const wrap = document.createElement('div');
+    wrap.className = 'bool-op-wrap';
+
+    const sel = document.createElement('select');
+    sel.className = 'select';
+    sel.dataset.role = 'bool-op';
+    const ops = Array.isArray(def.options) && def.options.length ? def.options : ['NONE', 'UNION', 'SUBTRACT', 'INTERSECT'];
+    for (const op of ops) {
+        const opt = document.createElement('option');
+        opt.value = String(op);
+        opt.textContent = String(op);
+        sel.appendChild(opt);
+    }
+    sel.value = String((ui.params[key].operation ?? ui.params[key].operation) || 'NONE');
+    sel.addEventListener('change', () => {
+        if (!ui.params[key] || typeof ui.params[key] !== 'object') ui.params[key] = { targets: [], operation: 'NONE' };
+        ui.params[key].operation = sel.value;
+        ui.params[key].operation = sel.value;
+        ui._emitParamsChange(key, ui.params[key]);
+    });
+    wrap.appendChild(sel);
+
+    const refWrap = document.createElement('div');
+    refWrap.className = 'ref-multi-wrap';
+    const chipsWrap = document.createElement('div');
+    chipsWrap.className = 'ref-chips';
+    refWrap.appendChild(chipsWrap);
+
+    const inputElTargets = document.createElement('input');
+    inputElTargets.type = 'text';
+    inputElTargets.className = 'input';
+    inputElTargets.dataset.multiple = 'true';
+    inputElTargets.placeholder = 'Click then select solids…';
+    ui._renderChips(chipsWrap, key, Array.isArray(ui.params[key].targets) ? ui.params[key].targets : []);
+
+    const activate = () => {
+        ui._activateReferenceSelection(inputElTargets, { selectionFilter: ['SOLID'] });
+    };
+    chipsWrap.addEventListener('click', activate);
+    inputElTargets.addEventListener('click', activate);
+
+    inputElTargets.addEventListener('change', () => {
+        if (inputElTargets.dataset && inputElTargets.dataset.forceClear === 'true') {
+            if (!ui.params[key] || typeof ui.params[key] !== 'object') ui.params[key] = { targets: [], operation: 'NONE' };
+            ui.params[key].targets = [];
+            ui._renderChips(chipsWrap, key, ui.params[key].targets);
+            inputElTargets.value = '';
+            delete inputElTargets.dataset.forceClear;
+            ui._emitParamsChange(key, ui.params[key]);
+            return;
+        }
+        if (!ui.params[key] || typeof ui.params[key] !== 'object') ui.params[key] = { targets: [], operation: 'NONE' };
+        let incoming = [];
+        try {
+            const parsed = JSON.parse(inputElTargets.value);
+            if (Array.isArray(parsed)) incoming = parsed;
+        } catch (_) {
+            if (inputElTargets.value && String(inputElTargets.value).trim() !== '') incoming = [String(inputElTargets.value).trim()];
+        }
+        const cur = Array.isArray(ui.params[key].targets) ? ui.params[key].targets : [];
+        for (const name of incoming) {
+            if (!cur.includes(name)) cur.push(name);
+        }
+        ui.params[key].targets = cur;
+        ui._renderChips(chipsWrap, key, cur);
+        inputElTargets.value = '';
+        ui._emitParamsChange(key, ui.params[key]);
+    });
+
+    refWrap.appendChild(inputElTargets);
+    wrap.appendChild(refWrap);
+
+    controlWrap.appendChild(wrap);
+
+    return {
+        inputEl: inputElTargets,
+        activate,
+        readValue() {
+            const current = ui.params[key];
+            if (!current || typeof current !== 'object') {
+                return { targets: [], operation: 'NONE' };
+            }
+            return {
+                targets: Array.isArray(current.targets) ? current.targets.slice() : [],
+                operation: current.operation || 'NONE',
+            };
+        },
+    };
+}

package/src/UI/featureDialogWidgets/buttonField.js

@@ -0,0 +1,45 @@
+export function renderButtonField({ ui, key, def, id }) {
+    const inputEl = document.createElement('button');
+    inputEl.type = 'button';
+    inputEl.id = id;
+    inputEl.className = 'btn';
+    inputEl.textContent = String(def.label || ui._prettyLabel(key));
+
+    inputEl.addEventListener('click', (ev) => {
+        ev.preventDefault();
+        ui._stopActiveReferenceSelection();
+        const fid = (ui.params && Object.prototype.hasOwnProperty.call(ui.params, 'featureID'))
+            ? ui.params.featureID
+            : (ui.params?.id ?? null);
+        let handled = false;
+        try {
+            if (def && typeof def.actionFunction === 'function') {
+                const ctx = {
+                    featureID: fid,
+                    key,
+                    viewer: ui.options?.viewer || null,
+                    partHistory: ui.options?.partHistory || null,
+                    feature: ui.options?.featureRef || null,
+                    params: ui.params,
+                    schemaDef: def,
+                };
+                const r = def.actionFunction(ctx);
+                handled = true;
+                void r;
+            }
+        } catch (_) { }
+        if (!handled) {
+            try { if (typeof ui.options.onAction === 'function') ui.options.onAction(fid, key); } catch (_) { }
+        }
+    });
+
+    return {
+        inputEl,
+        activate() {
+            inputEl.focus();
+        },
+        readValue() {
+            return null;
+        },
+    };
+}