@joint/core 4.0.4 → 4.1.0

package/src/shapes/standard.mjs

@@ -530,7 +530,8 @@ export const Cylinder = Element.define('standard.Cylinder', {
                     'Z'
                 ];
                 return { d: data.join(' ') };
-            }
+            },
+            unset: 'd'
         }
     }
 });
@@ -613,6 +614,12 @@ export const TextBlock = Element.define('standard.TextBlock', {
                     return { fill: style.color || null };
                 }
             },
+            unset: function(node) {
+                node.textContent = '';
+                if (node instanceof SVGElement) {
+                    return 'fill';
+                }
+            },
             position: function(text, refBBox, node) {
                 // No foreign object
                 if (node instanceof SVGElement) return refBBox.center();

package/src/{dia/attributes → util}/calc.mjs

@@ -10,18 +10,22 @@ const props = {
 const propsList = Object.keys(props).map(key => props[key]).join('');
 const numberPattern = '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?';
 const findSpacesRegex = /\s/g;
-const parseExpressionRegExp = new RegExp(`^(${numberPattern}\\*)?([${propsList}])(/${numberPattern})?([-+]{1,2}${numberPattern})?$`, 'g');
+const parseFormulaRegExp = new RegExp(`^(${numberPattern}\\*)?([${propsList}])(/${numberPattern})?([-+]{1,2}${numberPattern})?$`, 'g');
 
 function throwInvalid(expression) {
     throw new Error(`Invalid calc() expression: ${expression}`);
 }
 
-export function evalCalcExpression(expression, bbox) {
-    const match = parseExpressionRegExp.exec(expression.replace(findSpacesRegex, ''));
-    if (!match) throwInvalid(expression);
-    parseExpressionRegExp.lastIndex = 0; // reset regex results for the next run
+/*
+* Evaluate the given calc formula.
+* e.g. 'w + 10' in a rect 100x100 -> 110
+*/
+export function evalCalcFormula(formula, rect) {
+    const match = parseFormulaRegExp.exec(formula.replace(findSpacesRegex, ''));
+    if (!match) throwInvalid(formula);
+    parseFormulaRegExp.lastIndex = 0; // reset regex results for the next run
     const [,multiply, property, divide, add] = match;
-    const { x, y, width, height } = bbox;
+    const { x, y, width, height } = rect;
     let value = 0;
     switch (property) {
         case props.width: {
@@ -81,15 +85,23 @@ function evalAddExpression(addExpression) {
     return parseFloat(addExpression);
 }
 
-export function isCalcAttribute(value) {
+/*
+* Check if the given value is a calc expression.
+* e.g. 'calc(10 + 100)' -> true
+*/
+export function isCalcExpression(value) {
     return typeof value === 'string' && value.includes('calc');
 }
 
 const calcStart = 'calc(';
 const calcStartOffset = calcStart.length;
 
-export function evalCalcAttribute(attributeValue, refBBox) {
-    let value = attributeValue;
+/*
+* Evaluate all calc formulas in the given expression.
+* e.g. 'calc(w + 10)' in rect 100x100 -> '110'
+*/
+export function evalCalcExpression(expression, rect) {
+    let value = expression;
     let startSearchIndex = 0;
     do {
         let calcIndex = value.indexOf(calcStart, startSearchIndex);
@@ -116,11 +128,11 @@ export function evalCalcAttribute(attributeValue, refBBox) {
         } while (true);
         // Get the calc() expression without nested calcs (recursion)
         let expression = value.slice(calcIndex + calcStartOffset, calcEndIndex);
-        if (isCalcAttribute(expression)) {
-            expression = evalCalcAttribute(expression, refBBox);
+        if (isCalcExpression(expression)) {
+            expression = evalCalcExpression(expression, rect);
         }
         // Eval the calc() expression without nested calcs.
-        const calcValue = String(evalCalcExpression(expression, refBBox));
+        const calcValue = String(evalCalcFormula(expression, rect));
         // Replace the calc() expression and continue search
         value = value.slice(0, calcIndex) + calcValue + value.slice(calcEndIndex + 1);
         startSearchIndex = calcIndex + calcValue.length;

package/src/util/index.mjs

@@ -2,4 +2,5 @@ export * from './wrappers.mjs';
 export * from './util.mjs';
 export * from './cloneCells.mjs';
 export * from './svgTagTemplate.mjs';
+export * from './calc.mjs';
 export { getRectPoint } from './getRectPoint.mjs';

package/src/util/util.mjs

@@ -1708,6 +1708,45 @@ export const toggleFullScreen = function(el) {
     }
 };
 
+function findDifference(obj, baseObj, currentDepth, maxDepth) {
+
+    if (currentDepth === maxDepth) {
+        return {};
+    }
+
+    const diff = {};
+
+    Object.keys(obj).forEach((key) => {
+
+        const objValue = obj[key];
+        const baseValue = baseObj[key];
+
+        if (!Array.isArray(objValue) && !Array.isArray(baseValue) && isObject(objValue) && isObject(baseValue)) {
+
+            const nestedDepth = currentDepth + 1;
+            const nestedDiff = findDifference(objValue, baseValue, nestedDepth, maxDepth);
+
+            if (Object.keys(nestedDiff).length > 0) {
+                diff[key] = nestedDiff;
+            } else if ((currentDepth === 0 || nestedDepth === maxDepth)) {
+                diff[key] = {};
+            }
+
+        } else if (!isEqual(objValue, baseValue)) {
+            diff[key] = objValue;
+        }
+    });
+
+    return diff;
+}
+
+export function objectDifference(object, base, opt) {
+
+    const { maxDepth = Number.POSITIVE_INFINITY } = opt || {};
+
+    return findDifference(object, base, 0, maxDepth);
+}
+
 export {
     isBoolean,
     isObject,

package/src/util/utilHelpers.mjs

@@ -678,7 +678,8 @@ const equalByTag = (object, other, tag, equalFunc, stack) => {
         case stringTag:
             return object == `${other}`;
         case mapTag:
-            let convert = mapToArray;
+            // This use of 'var' is intentional. Don't remove if replacing all instances.
+            var convert = mapToArray;
         // Intentional fallthrough
         // eslint-disable-next-line no-fallthrough
         case setTag:

package/types/geometry.d.ts

@@ -37,6 +37,11 @@ export namespace g {
         precision?: number;
     }
 
+    export interface StrictOpt {
+
+        strict?: boolean;
+    }
+
     export interface SubdivisionsOpt extends PrecisionOpt {
 
         subdivisions?: Curve[];
@@ -644,7 +649,7 @@ export namespace g {
 
         clone(): Rect;
 
-        containsPoint(p: PlainPoint | string): boolean;
+        containsPoint(p: PlainPoint | string, opt?: StrictOpt): boolean;
 
         containsRect(r: PlainRect): boolean;