meshwriter-cudu 3.0.0

package/src/umd-entry.js

@@ -0,0 +1,130 @@
+/**
+ * MeshWriter UMD Entry Point
+ * Bundles fonts and attaches to window.MeshWriter and BABYLON.MeshWriter
+ */
+
+import {
+    createMeshWriter,
+    createMeshWriterAsync,
+    isCSGReady,
+    getCSGVersion,
+    setCSGInitializer,
+    setCSGReadyCheck,
+    onCSGReady,
+    markCSGReady,
+    initCSGModule
+} from './meshwriter.js';
+
+import {
+    registerFont,
+    registerFontAliases,
+    getFont,
+    isFontRegistered,
+    codeList,
+    decodeList
+} from './fontRegistry.js';
+
+// Import all fonts for UMD bundle
+import helvetica from '../fonts/helvetica.js';
+import comicSans from '../fonts/comic-sans.js';
+import jura from '../fonts/jura.js';
+import hirukoPro from '../fonts/hiruko-pro.js';
+import webglDings from '../fonts/webgl-dings.js';
+
+// Register fonts with standard names
+registerFont('HelveticaNeue-Medium', helvetica);
+registerFont('Helvetica', helvetica);
+registerFont('Arial', helvetica);
+registerFont('sans-serif', helvetica);
+registerFont('HirukoPro-Book', hirukoPro);
+registerFont('Comic', comicSans);
+registerFont('comic', comicSans);
+registerFont('ComicSans', comicSans);
+registerFont('Jura', jura);
+registerFont('jura', jura);
+registerFont('WebGL-Dings', webglDings);
+registerFont('Web-dings', webglDings);
+
+/**
+ * Get the BABYLON global if available
+ * @returns {any}
+ */
+function getBabylonGlobal() {
+    if (typeof globalThis !== 'undefined' && globalThis.BABYLON) {
+        return globalThis.BABYLON;
+    }
+    return undefined;
+}
+
+/**
+ * Legacy MeshWriter factory function
+ * Matches the old API: var Writer = BABYLON.MeshWriter(scene, prefs)
+ * @param {any} scene
+ * @param {any} preferences
+ */
+function MeshWriterFactory(scene, preferences) {
+    // Initialize CSG from BABYLON global
+    const babylon = getBabylonGlobal();
+    if (babylon) {
+        initCSGModule(babylon);
+    }
+    return createMeshWriter(scene, preferences);
+}
+
+// Attach static methods to factory
+/** @type {any} */
+const factory = MeshWriterFactory;
+
+factory.createAsync = async function(scene, preferences = {}) {
+    // Initialize CSG from BABYLON global
+    const babylon = getBabylonGlobal();
+    if (babylon) {
+        initCSGModule(babylon);
+    }
+    return createMeshWriterAsync(scene, preferences);
+};
+
+// Sync create method (alias for backwards compatibility)
+factory.create = function(scene, preferences = {}) {
+    const babylon = getBabylonGlobal();
+    if (babylon) {
+        initCSGModule(babylon);
+    }
+    return createMeshWriter(scene, preferences);
+};
+
+factory.isReady = isCSGReady;
+factory.getCSGVersion = getCSGVersion;
+factory.setCSGInitializer = setCSGInitializer;
+factory.setCSGReadyCheck = setCSGReadyCheck;
+factory.onCSGReady = onCSGReady;
+factory.markCSGReady = markCSGReady;
+factory.registerFont = registerFont;
+factory.getFont = getFont;
+factory.isFontRegistered = isFontRegistered;
+factory.codeList = codeList;
+factory.decodeList = decodeList;
+
+// Attach to globals for browser usage
+if (typeof window !== 'undefined') {
+    /** @type {any} */
+    const win = window;
+    win.MeshWriter = factory;
+    win.TYPE = factory; // Legacy name
+}
+
+if (typeof globalThis !== 'undefined') {
+    /** @type {any} */
+    const gt = globalThis;
+    if (gt.global) {
+        gt.global.MeshWriter = factory;
+    }
+}
+
+// Attach to BABYLON namespace if available
+const babylon = getBabylonGlobal();
+if (babylon) {
+    babylon.MeshWriter = factory;
+}
+
+export default factory;

package/src/utils.js

@@ -0,0 +1,57 @@
+/**
+ * MeshWriter Utility Functions
+ * Pure helper functions with no external dependencies
+ */
+
+const floor = Math.floor;
+
+// Type checking functions
+export function isPositiveNumber(mn) {
+    return typeof mn === "number" && !isNaN(mn) ? 0 < mn : false;
+}
+
+export function isNumber(mn) {
+    return typeof mn === "number";
+}
+
+export function isBoolean(mn) {
+    return typeof mn === "boolean";
+}
+
+export function isAmplitude(ma) {
+    return typeof ma === "number" && !isNaN(ma) ? 0 <= ma && ma <= 1 : false;
+}
+
+export function isObject(mo) {
+    return mo != null && typeof mo === "object" || typeof mo === "function";
+}
+
+export function isPromiseLike(mo) {
+    return isObject(mo) && typeof mo.then === "function";
+}
+
+export function isArray(ma) {
+    return ma != null && typeof ma === "object" && ma.constructor === Array;
+}
+
+export function isString(ms) {
+    return typeof ms === "string" ? ms.length > 0 : false;
+}
+
+export function isRelativeLength(l) {
+    return l === 3 || l === 5 || l === 7;
+}
+
+// Math utilities
+export function round(n) {
+    return floor(0.3 + n * 1000000) / 1000000;
+}
+
+export function weeid() {
+    return Math.floor(Math.random() * 1000000);
+}
+
+// Option handling
+export function setOption(opts, field, tst, defalt) {
+    return tst(opts[field]) ? opts[field] : defalt;
+}