brep-io-kernel 1.0.96 → 1.0.97

package/src/main.js

@@ -28,6 +28,7 @@ import {
 import { WorkspaceFileBrowserWidget } from './UI/WorkspaceFileBrowserWidget.js';
 import './UI/dialogs.js';
 import './styles/landing.css';
+import brepHomeBannerSvg from './assets/brand/brep-home-banner.svg?raw';
 
 const MODEL_FILE_EXTENSION = '.3mf';
 const MANUAL_WORKSPACE_REPOS_KEY = '__BREP_WORKSPACE_MANUAL_REPOS__';
@@ -649,7 +650,7 @@ async function renderHome() {
       <div class="hub-bg hub-bg-two"></div>
       <header class="hub-header">
         <div class="hub-brand-wrap">
-          <img class="hub-brand-banner" src="./brep-home-banner.svg" alt="BREP.io logo" />
+          <div class="hub-brand-banner" aria-label="BREP.io logo">${brepHomeBannerSvg}</div>
         </div>
         <div class="hub-header-actions">
           <a class="hub-link-btn" href="./help/developer-index.html" target="_blank" rel="noreferrer">Docs</a>

package/src/styles/cad.css

@@ -74,8 +74,13 @@ body {
   width: 100%;
   height: 100%;
   max-width: 100%;
-  object-fit: contain;
-  object-position: left center;
   pointer-events: none;
   user-select: none;
 }
+
+.cad-sidebar-home-banner-img > svg {
+  display: block;
+  width: 100%;
+  height: 100%;
+  max-width: 100%;
+}

package/src/styles/landing.css

@@ -124,11 +124,17 @@ body {
 .hub-brand-banner {
   display: block;
   width: min(760px, 100%);
-  height: auto;
   max-width: 100%;
   filter: drop-shadow(0 5px 14px rgba(6, 14, 36, 0.26));
 }
 
+.hub-brand-banner > svg {
+  display: block;
+  width: 100%;
+  height: auto;
+  max-width: 100%;
+}
+
 .hub-eyebrow {
   font-family: var(--hub-mono-font);
   letter-spacing: .18em;

package/src/tools/fontAuditPage.js

@@ -0,0 +1,354 @@
+const SAMPLE_FOX = 'The quick brown fox jumps over the lazy dog';
+const SAMPLE_DIGITS = '0123456789';
+
+const FONT_URLS = import.meta.glob('../assets/fonts/**/*.{ttf,otf,woff,woff2,ttc}', {
+  eager: true,
+  query: '?url',
+  import: 'default',
+});
+
+const cssEscapeValue = (value) => String(value || '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+
+const extFromPath = (path) => {
+  const m = String(path || '').toLowerCase().match(/\.([^.]+)$/);
+  return m ? m[1] : '';
+};
+
+const formatHintFromExt = (path) => {
+  const ext = extFromPath(path);
+  if (ext === 'ttf') return 'truetype';
+  if (ext === 'otf') return 'opentype';
+  if (ext === 'woff') return 'woff';
+  if (ext === 'woff2') return 'woff2';
+  if (ext === 'ttc') return 'truetype';
+  return '';
+};
+
+const prettyNameFromPath = (relPath) => {
+  const base = String(relPath || '')
+    .split('/')
+    .pop() || '';
+  return base
+    .replace(/\.[^.]+$/, '')
+    .replace(/[_-]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+};
+
+const normalizeRelPath = (key) => String(key || '').replace(/^..\/assets\/fonts\//, '').replace(/\\/g, '/');
+
+const formatBytes = (bytes) => {
+  if (!Number.isFinite(bytes) || bytes < 0) return 'unknown';
+  if (bytes < 1024) return `${bytes} B`;
+  const kb = bytes / 1024;
+  if (kb < 1024) return `${kb.toFixed(1)} KB`;
+  const mb = kb / 1024;
+  return `${mb.toFixed(2)} MB`;
+};
+
+const compareByName = (a, b) => {
+  const byName = a.name.localeCompare(b.name, undefined, { sensitivity: 'base' });
+  if (byName !== 0) return byName;
+  return a.relPath.localeCompare(b.relPath, undefined, { sensitivity: 'base' });
+};
+
+const compareBySize = (a, b, descending) => {
+  const aKnown = Number.isFinite(a.sizeBytes);
+  const bKnown = Number.isFinite(b.sizeBytes);
+
+  if (aKnown && bKnown) {
+    const diff = a.sizeBytes - b.sizeBytes;
+    if (diff !== 0) return descending ? -diff : diff;
+  }
+
+  if (aKnown !== bKnown) return aKnown ? -1 : 1;
+  return compareByName(a, b);
+};
+
+const sortEntriesInPlace = (entries, sortMode) => {
+  entries.sort((a, b) => {
+    if (sortMode === 'name-desc') return -compareByName(a, b);
+    if (sortMode === 'size-desc') return compareBySize(a, b, true);
+    if (sortMode === 'size-asc') return compareBySize(a, b, false);
+    return compareByName(a, b);
+  });
+};
+
+const fetchFontSizeBytes = async (url) => {
+  try {
+    const head = await fetch(url, { method: 'HEAD', cache: 'force-cache' });
+    if (head.ok) {
+      const len = Number(head.headers.get('content-length'));
+      if (Number.isFinite(len) && len > 0) return len;
+    }
+  } catch {
+    // Fall through to GET.
+  }
+
+  const res = await fetch(url, { cache: 'force-cache' });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  const buf = await res.arrayBuffer();
+  return buf.byteLength;
+};
+
+const mapLimit = async (items, limit, mapper) => {
+  const maxWorkers = Math.max(1, Math.min(limit, items.length || 1));
+  let nextIndex = 0;
+  const workers = Array.from({ length: maxWorkers }, async () => {
+    while (true) {
+      const idx = nextIndex++;
+      if (idx >= items.length) break;
+      await mapper(items[idx], idx);
+    }
+  });
+  await Promise.all(workers);
+};
+
+const createFontEntries = () => {
+  const entries = Object.entries(FONT_URLS).map(([key, url], idx) => {
+    const relPath = normalizeRelPath(key);
+    return {
+      idx,
+      relPath,
+      url,
+      name: prettyNameFromPath(relPath),
+      sizeBytes: null,
+      sizeText: 'loading...',
+      familyName: `__font_audit_${idx}`,
+      rowEl: null,
+      checkboxEl: null,
+      sizeEl: null,
+    };
+  });
+  return entries;
+};
+
+const injectFontFaces = (entries) => {
+  const style = document.createElement('style');
+  const css = entries
+    .map((entry) => {
+      const family = cssEscapeValue(entry.familyName);
+      const url = cssEscapeValue(entry.url);
+      const format = formatHintFromExt(entry.relPath);
+      const formatPart = format ? ` format("${format}")` : '';
+      return `@font-face{font-family:"${family}";src:url("${url}")${formatPart};font-display:swap;}`;
+    })
+    .join('\n');
+  style.textContent = css;
+  document.head.appendChild(style);
+};
+
+const buildRow = (entry) => {
+  const row = document.createElement('article');
+  row.className = 'font-row';
+
+  const head = document.createElement('div');
+  head.className = 'font-row-head';
+
+  const checkbox = document.createElement('input');
+  checkbox.type = 'checkbox';
+  checkbox.checked = false;
+  checkbox.setAttribute('aria-label', `Select ${entry.name}`);
+  head.appendChild(checkbox);
+
+  const labelWrap = document.createElement('div');
+  const nameEl = document.createElement('div');
+  nameEl.className = 'font-row-name';
+  nameEl.textContent = entry.name || entry.relPath;
+  const metaEl = document.createElement('div');
+  metaEl.className = 'font-row-meta';
+  metaEl.textContent = entry.relPath;
+  labelWrap.appendChild(nameEl);
+  labelWrap.appendChild(metaEl);
+  head.appendChild(labelWrap);
+
+  const sizeEl = document.createElement('div');
+  sizeEl.className = 'font-row-size';
+  sizeEl.textContent = 'loading...';
+  head.appendChild(sizeEl);
+
+  row.appendChild(head);
+
+  const sample = document.createElement('div');
+  sample.className = 'font-sample';
+  sample.style.fontFamily = `"${entry.familyName}", ui-sans-serif, system-ui, sans-serif`;
+
+  const foxEl = document.createElement('div');
+  foxEl.className = 'font-sample-fox';
+  foxEl.textContent = SAMPLE_FOX;
+  sample.appendChild(foxEl);
+
+  const digitsEl = document.createElement('div');
+  digitsEl.className = 'font-sample-digits';
+  digitsEl.textContent = SAMPLE_DIGITS;
+  sample.appendChild(digitsEl);
+
+  row.appendChild(sample);
+
+  entry.rowEl = row;
+  entry.checkboxEl = checkbox;
+  entry.sizeEl = sizeEl;
+  return row;
+};
+
+const renderRows = (entries, listEl) => {
+  const frag = document.createDocumentFragment();
+  for (const entry of entries) {
+    if (entry.rowEl) frag.appendChild(entry.rowEl);
+  }
+  listEl.appendChild(frag);
+};
+
+const updateStatus = (entries, statusEl) => {
+  const selected = entries.filter((entry) => entry.checkboxEl?.checked).length;
+  const knownSizes = entries.filter((entry) => Number.isFinite(entry.sizeBytes));
+  const totalKnown = knownSizes.reduce((sum, entry) => sum + entry.sizeBytes, 0);
+  statusEl.textContent = `${entries.length} fonts • ${selected} selected • known size ${formatBytes(totalKnown)}`;
+};
+
+const applyVisibilityFilter = (entries, searchTerm, selectedOnly) => {
+  const query = String(searchTerm || '').trim().toLowerCase();
+  for (const entry of entries) {
+    const matchesQuery =
+      !query ||
+      entry.name.toLowerCase().includes(query) ||
+      entry.relPath.toLowerCase().includes(query);
+    const matchesSelected = !selectedOnly || !!entry.checkboxEl?.checked;
+    const visible = matchesQuery && matchesSelected;
+    entry.rowEl?.classList.toggle('hidden', !visible);
+  }
+};
+
+const buildSelectedListText = (entries) => {
+  const selected = entries.filter((entry) => entry.checkboxEl?.checked);
+  const knownTotal = selected.reduce(
+    (sum, entry) => sum + (Number.isFinite(entry.sizeBytes) ? entry.sizeBytes : 0),
+    0
+  );
+
+  const lines = [];
+  lines.push(`Selected fonts: ${selected.length}`);
+  lines.push(`Known total size: ${formatBytes(knownTotal)}`);
+  lines.push('');
+  lines.push('Path\tSize');
+
+  for (const entry of selected) {
+    lines.push(`${entry.relPath}\t${formatBytes(entry.sizeBytes)}`);
+  }
+
+  return lines.join('\n');
+};
+
+const loadFontSizes = async (entries, statusEl) => {
+  let completed = 0;
+  await mapLimit(entries, 8, async (entry) => {
+    try {
+      entry.sizeBytes = await fetchFontSizeBytes(entry.url);
+      entry.sizeText = formatBytes(entry.sizeBytes);
+    } catch {
+      entry.sizeBytes = null;
+      entry.sizeText = 'size unavailable';
+    }
+    if (entry.sizeEl) entry.sizeEl.textContent = entry.sizeText;
+    completed += 1;
+    if (statusEl) {
+      statusEl.textContent = `Loading sizes... ${completed}/${entries.length}`;
+    }
+  });
+};
+
+const initFontAuditPage = () => {
+  const listEl = document.getElementById('font-list');
+  const statusEl = document.getElementById('font-audit-status');
+  const outputEl = document.getElementById('font-selection-output');
+  const selectAllBtn = document.getElementById('btn-select-all');
+  const clearAllBtn = document.getElementById('btn-clear-all');
+  const generateBtn = document.getElementById('btn-generate-list');
+  const copyBtn = document.getElementById('btn-copy-list');
+  const filterInput = document.getElementById('font-filter');
+  const sortInput = document.getElementById('font-sort');
+  const showSelectedOnlyInput = document.getElementById('show-selected-only');
+
+  if (!listEl || !statusEl || !outputEl || !selectAllBtn || !clearAllBtn || !generateBtn || !copyBtn || !filterInput || !sortInput || !showSelectedOnlyInput) {
+    return;
+  }
+
+  const entries = createFontEntries();
+  injectFontFaces(entries);
+
+  const refreshStatus = () => updateStatus(entries, statusEl);
+  const refreshFilter = () =>
+    applyVisibilityFilter(entries, filterInput.value, !!showSelectedOnlyInput.checked);
+  const refreshSort = () => {
+    sortEntriesInPlace(entries, sortInput.value || 'name-asc');
+    renderRows(entries, listEl);
+  };
+
+  for (const entry of entries) {
+    const row = buildRow(entry);
+    listEl.appendChild(row);
+    entry.checkboxEl?.addEventListener('change', () => {
+      refreshStatus();
+      refreshFilter();
+    });
+  }
+
+  selectAllBtn.addEventListener('click', () => {
+    for (const entry of entries) {
+      if (entry.checkboxEl) entry.checkboxEl.checked = true;
+    }
+    refreshStatus();
+    refreshFilter();
+  });
+
+  clearAllBtn.addEventListener('click', () => {
+    for (const entry of entries) {
+      if (entry.checkboxEl) entry.checkboxEl.checked = false;
+    }
+    refreshStatus();
+    refreshFilter();
+  });
+
+  generateBtn.addEventListener('click', () => {
+    outputEl.value = buildSelectedListText(entries);
+  });
+
+  copyBtn.addEventListener('click', async () => {
+    const text = outputEl.value || '';
+    if (!text.trim()) return;
+    try {
+      await navigator.clipboard.writeText(text);
+      copyBtn.textContent = 'Copied';
+      window.setTimeout(() => {
+        copyBtn.textContent = 'Copy List';
+      }, 1000);
+    } catch {
+      copyBtn.textContent = 'Copy Failed';
+      window.setTimeout(() => {
+        copyBtn.textContent = 'Copy List';
+      }, 1200);
+    }
+  });
+
+  filterInput.addEventListener('input', refreshFilter);
+  showSelectedOnlyInput.addEventListener('change', refreshFilter);
+  sortInput.addEventListener('change', () => {
+    refreshSort();
+    refreshFilter();
+  });
+
+  refreshSort();
+  refreshStatus();
+  refreshFilter();
+
+  loadFontSizes(entries, statusEl)
+    .catch(() => {
+      statusEl.textContent = 'Loaded fonts with partial size info.';
+    })
+    .finally(() => {
+      refreshSort();
+      refreshStatus();
+    });
+};
+
+initFontAuditPage();

package/src/assets/fonts/google-ofl/anektelugu/DESCRIPTION.en_us.html

@@ -1,23 +0,0 @@
-<p> Anek, as the meaning of the word suggests, is an exercise in multiplicity — multiple scripts designed in multiple
-    weights and widths by multiple designers. A well-informed, conscientious and refreshing interpretation of India’s
-    letter traditions, this family offers a versatile system that can meet the demands of a wide range of applications.
-</p>
-
-<p> Its expansive design space allows Anek to don multiple personalities. At its most condensed, capsular forms keep
-    structures compact for that graphic texture. On the wide end of the spectrum, the extra legroom lets each letter
-    yawn and stretch into their message. But it is in the boldest weights that Anek comes alive. Sharp terminals and
-    tapered joineries sparkle amidst regimented forms, making this ideal for setting titillating headlines or that
-    magnetic word-mark.</p>
-
-<p> Anek comes in <a href="/?query=Anek">ten scripts</a>: Bangla, Devanagari, Kannada, Latin, Gujarati, Gurmukhi,
-    Malayalam, Odia, Tamil and Telugu. The shared aesthetics of this type-family are drawn from a collaboratively
-    decided pool of visual features. At the same time, each script amalgamates influences from its own typographic
-    culture as well as the perspectives of individual designers. </p>
-
-<p> This project is designed, engineered and maintained by Ek Type; a collective of type designers based in Mumbai
-    focused on designing contemporary Indian typefaces. Contributors of this project are: Maithili Shingre (Anek
-    Malayalam, Anek Kannada), Yesha Goshar (Anek Latin, Anek Odia), Kailash Malviya (Anek Devanagari), Aadarsh Rajan
-    (Anek Tamil), Sulekha Rajkumar (Anek Bangla), Vaishnavi Murthy (Anek Kannada), Omkar Bhoir (Anek Telugu), Mrunmayee
-    Ghaisas (Anek Gujarati), Mahesh Sahu (Anek Odia), and Sarang Kulkarni (Anek Gurmukhi). Project management and design
-    assistance by Noopur Datye, and Font engineering and design assistance by Girish Dalvi.</p>
-<p> To contribute, see <a href="https://github.com/EkType/Anek/">github.com/EkType/Anek</a></p>

package/src/assets/fonts/google-ofl/anektelugu/METADATA.pb

@@ -1,47 +0,0 @@
-name: "Anek Telugu"
-designer: "Ek Type"
-license: "OFL"
-category: "SANS_SERIF"
-date_added: "2022-02-16"
-fonts {
-  name: "Anek Telugu"
-  style: "normal"
-  weight: 400
-  filename: "AnekTelugu[wdth,wght].ttf"
-  post_script_name: "AnekTelugu-Medium"
-  full_name: "Anek Telugu Medium"
-  copyright: "Copyright 2021 The Anek Project Authors (https://github.com/EkType/Anek)"
-}
-subsets: "latin"
-subsets: "latin-ext"
-subsets: "menu"
-subsets: "telugu"
-axes {
-  tag: "wdth"
-  min_value: 75.0
-  max_value: 125.0
-}
-axes {
-  tag: "wght"
-  min_value: 100.0
-  max_value: 800.0
-}
-source {
-  repository_url: "https://github.com/EkType/Anek"
-  commit: "34074c6b406f4112e20c7ad10254a6e954d0324b"
-  config_yaml: "sources/AnekTelugu/builder.yaml"
-  files {
-    source_file: "OFL.txt"
-    dest_file: "OFL.txt"
-  }
-  files {
-    source_file: "fonts/AnekTelugu/variable/AnekTelugu[wdth,wght].ttf"
-    dest_file: "AnekTelugu[wdth,wght].ttf"
-  }
-  files {
-    source_file: "DESCRIPTION.en_us.html"
-    dest_file: "DESCRIPTION.en_us.html"
-  }
-  branch: "main"
-}
-primary_script: "Telu"

package/src/assets/fonts/google-ofl/anektelugu/OFL.txt

@@ -1,93 +0,0 @@
-Copyright 2021 The Anek Project Authors (https://github.com/EkType/Anek)
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
-
-
------------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
------------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded, 
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.

package/src/assets/fonts/google-ofl/anton/DESCRIPTION.en_us.html

@@ -1,12 +0,0 @@
-<p>
-Anton is a reworking of a traditional advertising sans serif typeface. The
-letter forms have been digitised and then reshaped for use as a webfont, the
-counters have been opened up a little and the stems optimised for use as bold
-display font in modern web browsers.
-</p>
-<p>
-Anton language support includes now African Latin and full coverage of Vietnamese, additional to all Western, Central, and South-Eastern European languages.
-</p>
-<p> 
-To contribute see <a href="https://github.com/googlefonts/AntonFont" target="_blank">github.com/googlefonts/AntonFont</a>.
-</p>

package/src/assets/fonts/google-ofl/anton/METADATA.pb

@@ -1,38 +0,0 @@
-name: "Anton"
-designer: "Vernon Adams"
-license: "OFL"
-category: "DISPLAY"
-date_added: "2011-02-23"
-fonts {
-  name: "Anton"
-  style: "normal"
-  weight: 400
-  filename: "Anton-Regular.ttf"
-  post_script_name: "Anton-Regular"
-  full_name: "Anton Regular"
-  copyright: "Copyright 2020 The Anton Project Authors (https://github.com/googlefonts/AntonFont.git)"
-}
-subsets: "latin"
-subsets: "latin-ext"
-subsets: "menu"
-subsets: "vietnamese"
-source {
-  repository_url: "https://github.com/googlefonts/AntonFont"
-  commit: "beb92fcad87808357123bb66881b4032dc96efe7"
-  files {
-    source_file: "OFL.txt"
-    dest_file: "OFL.txt"
-  }
-  files {
-    source_file: "DESCRIPTION.en_us.html"
-    dest_file: "DESCRIPTION.en_us.html"
-  }
-  files {
-    source_file: "fonts/Anton-Regular.ttf"
-    dest_file: "Anton-Regular.ttf"
-  }
-  branch: "master"
-  config_yaml: "sources/config.yaml"
-}
-stroke: "SANS_SERIF"
-classifications: "DISPLAY"