modern-idoc 0.6.0 → 0.6.2

package/dist/index.cjs

@@ -10,6 +10,38 @@ function normalizeAudio(audio) {
   }
 }
 
+function isNone(value) {
+  return value === null || value === void 0 || value === "none";
+}
+function round(number, digits = 0, base = 10 ** digits) {
+  return Math.round(base * number) / base + 0;
+}
+function clearUndef(obj, deep = false) {
+  if (typeof obj !== "object" || !obj) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    if (deep) {
+      return obj.map((v) => clearUndef(v, deep));
+    } else {
+      return obj;
+    }
+  }
+  const newObj = {};
+  for (const key in obj) {
+    const value = obj[key];
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (deep) {
+      newObj[key] = clearUndef(value, deep);
+    } else {
+      newObj[key] = value;
+    }
+  }
+  return newObj;
+}
+
 function parseColor(color) {
   let input;
   if (typeof color === "number") {
@@ -24,9 +56,6 @@ function parseColor(color) {
   }
   return colord.colord(input);
 }
-function round(number, digits = 0, base = 10 ** digits) {
-  return Math.round(base * number) / base + 0;
-}
 function roundRgba(rgba) {
   return {
     r: round(rgba.r),
@@ -40,6 +69,9 @@ function format(number) {
   return hex.length < 2 ? `0${hex}` : hex;
 }
 const defaultColor = "#000000FF";
+function isColor(value) {
+  return parseColor(value).isValid();
+}
 function normalizeColor(color, orFail = false) {
   const parsed = parseColor(color);
   if (!parsed.isValid()) {
@@ -574,16 +606,11 @@ GradientParser.stringify = /* @__PURE__ */ function() {
 }();
 const stringifyGradient = GradientParser.stringify.bind(GradientParser);
 
-function parseLinearGradientNode(node) {
-  let angle = 0;
-  switch (node.orientation?.type) {
-    case "angular":
-      angle = Number(node.orientation.value);
-      break;
-  }
-  const stops = node.colorStops.map((stop) => {
+function parseColorStopNodeList(colorStops) {
+  const count = colorStops.length - 1;
+  return colorStops.map((stop, index) => {
     const value = stop.value;
-    let offset = 0;
+    let offset = round(index / count, 3);
     let color = "#00000000";
     switch (stop.type) {
       case "rgb":
@@ -605,7 +632,7 @@ function parseLinearGradientNode(node) {
         color = normalizeColor(stop.value);
         break;
       case "hex":
-        color = normalizeColor(stop.value);
+        color = normalizeColor(`#${stop.value}`);
         break;
     }
     switch (stop.length?.type) {
@@ -615,14 +642,22 @@ function parseLinearGradientNode(node) {
     }
     return { offset, color };
   });
+}
+function parseLinearGradientNode(node) {
+  let angle = 0;
+  switch (node.orientation?.type) {
+    case "angular":
+      angle = Number(node.orientation.value);
+      break;
+  }
   return {
     type: "linear-gradient",
     angle,
-    stops
+    stops: parseColorStopNodeList(node.colorStops)
   };
 }
-function parseRadialGradientNode(ast) {
-  ast.orientation?.map((item) => {
+function parseRadialGradientNode(node) {
+  node.orientation?.map((item) => {
     switch (item?.type) {
       case "shape":
       case "default-radial":
@@ -631,45 +666,14 @@ function parseRadialGradientNode(ast) {
         return null;
     }
   });
-  const stops = ast.colorStops.map((stop) => {
-    const value = stop.value;
-    let offset = 0;
-    let color = "#00000000";
-    switch (stop.type) {
-      case "rgb":
-        color = normalizeColor({
-          r: Number(value[0] ?? 0),
-          g: Number(value[1] ?? 0),
-          b: Number(value[2] ?? 0)
-        });
-        break;
-      case "rgba":
-        color = normalizeColor({
-          r: Number(value[0] ?? 0),
-          g: Number(value[1] ?? 0),
-          b: Number(value[2] ?? 0),
-          a: Number(value[3] ?? 0)
-        });
-        break;
-      case "literal":
-        color = normalizeColor(stop.value);
-        break;
-      case "hex":
-        color = normalizeColor(stop.value);
-        break;
-    }
-    switch (stop.length?.type) {
-      case "%":
-        offset = Number(stop.length.value) / 100;
-        break;
-    }
-    return { offset, color };
-  });
   return {
     type: "radial-gradient",
-    stops
+    stops: parseColorStopNodeList(node.colorStops)
   };
 }
+function isGradient(cssText) {
+  return cssText.startsWith("linear-gradient") || cssText.startsWith("radial-gradient");
+}
 function normalizeGradient(cssText) {
   return parseGradient(cssText).map((node) => {
     switch (node?.type) {
@@ -687,53 +691,92 @@ function normalizeGradient(cssText) {
   }).filter(Boolean);
 }
 
-function isNone(value) {
-  return value === null || value === void 0 || value === "none";
+function normalizeColorFill(fill) {
+  let obj;
+  if (typeof fill === "string") {
+    obj = { color: fill };
+  } else {
+    obj = fill;
+  }
+  return {
+    color: normalizeColor(obj.color)
+  };
 }
-function clearUndef(obj, deep = false) {
-  if (typeof obj !== "object" || !obj) {
-    return obj;
+
+function normalizeGradientFill(fill) {
+  let obj;
+  if (typeof fill === "string") {
+    obj = { image: fill };
+  } else {
+    obj = fill;
   }
-  if (Array.isArray(obj)) {
-    if (deep) {
-      return obj.map((v) => clearUndef(v, deep));
-    } else {
-      return obj;
-    }
+  const res = normalizeGradient(obj.image)[0];
+  switch (res?.type) {
+    case "radial-gradient":
+      return {
+        radialGradient: res
+      };
+    case "linear-gradient":
+      return {
+        linearGradient: res
+      };
   }
-  const newObj = {};
-  for (const key in obj) {
-    const value = obj[key];
-    if (value === void 0 || value === null) {
-      continue;
-    }
-    if (deep) {
-      newObj[key] = clearUndef(value, deep);
-    } else {
-      newObj[key] = value;
-    }
+  return {};
+}
+
+function normalizeImageFill(fill) {
+  return fill;
+}
+
+function normalizePresetFill(fill) {
+  let obj;
+  if (typeof fill === "string") {
+    obj = { preset: fill };
+  } else {
+    obj = fill;
   }
-  return newObj;
+  return {
+    preset: obj.preset,
+    foregroundColor: isNone(obj.foregroundColor) ? void 0 : normalizeColor(obj.foregroundColor),
+    backgroundColor: isNone(obj.backgroundColor) ? void 0 : normalizeColor(obj.backgroundColor)
+  };
 }
 
 function normalizeFill(fill) {
   if (typeof fill === "string") {
-    return { color: normalizeColor(fill) };
+    if (isColor(fill)) {
+      return normalizeColorFill({ color: fill });
+    } else if (isGradient(fill)) {
+      return normalizeGradientFill({ image: fill });
+    } else {
+      return normalizeImageFill({ image: fill });
+    }
   } else {
-    return {
-      ...fill,
-      color: isNone(fill.color) ? void 0 : normalizeColor(fill.color)
-    };
+    if (!isNone(fill.color)) {
+      return normalizeColorFill(fill);
+    } else if (!isNone(fill.image)) {
+      if (isGradient(fill.image)) {
+        return normalizeGradientFill(fill);
+      } else {
+        return normalizeImageFill(fill);
+      }
+    } else if (isNone(fill.preset)) {
+      return normalizePresetFill(fill);
+    }
   }
+  throw new Error("Unknown fill property object");
 }
 
 function normalizeBackground(background) {
   if (typeof background === "string") {
-    return { src: background };
+    return {
+      ...normalizeFill(background),
+      fillWithShape: false
+    };
   } else {
     return {
-      ...background,
-      ...normalizeFill(background)
+      ...normalizeFill(background),
+      fillWithShape: Boolean(background.fillWithShape)
     };
   }
 }
@@ -785,35 +828,15 @@ function normalizeEffect(effect) {
 
 function normalizeForeground(foreground) {
   if (typeof foreground === "string") {
-    return { src: foreground };
-  } else {
     return {
-      ...foreground,
-      ...normalizeFill(foreground)
+      ...normalizeFill(foreground),
+      fillWithShape: false
     };
-  }
-}
-
-function normalizeGeometry(geometry) {
-  if (typeof geometry === "string") {
-    return {
-      paths: [
-        { data: geometry }
-      ]
-    };
-  } else if (Array.isArray(geometry)) {
+  } else {
     return {
-      paths: geometry.map((data) => {
-        if (typeof data === "string") {
-          return {
-            data
-          };
-        }
-        return data;
-      })
+      ...normalizeFill(foreground),
+      fillWithShape: Boolean(foreground.fillWithShape)
     };
-  } else {
-    return geometry;
   }
 }
 
@@ -848,6 +871,29 @@ function getDefaultShadowStyle() {
   };
 }
 
+function normalizeShape(shape) {
+  if (typeof shape === "string") {
+    return {
+      paths: [
+        { data: shape }
+      ]
+    };
+  } else if (Array.isArray(shape)) {
+    return {
+      paths: shape.map((data) => {
+        if (typeof data === "string") {
+          return {
+            data
+          };
+        }
+        return data;
+      })
+    };
+  } else {
+    return shape;
+  }
+}
+
 function getDefaultLayoutStyle() {
   return {
     // box
@@ -1100,7 +1146,7 @@ function normalizeElement(element) {
     style: isNone(element.style) ? void 0 : normalizeStyle(element.style),
     text: isNone(element.text) ? void 0 : normalizeText(element.text),
     background: isNone(element.background) ? void 0 : normalizeBackground(element.background),
-    geometry: isNone(element.geometry) ? void 0 : normalizeGeometry(element.geometry),
+    shape: isNone(element.shape) ? void 0 : normalizeShape(element.shape),
     fill: isNone(element.fill) ? void 0 : normalizeFill(element.fill),
     outline: isNone(element.outline) ? void 0 : normalizeOutline(element.outline),
     foreground: isNone(element.foreground) ? void 0 : normalizeForeground(element.foreground),
@@ -1130,21 +1176,27 @@ exports.getDefaultTextInlineStyle = getDefaultTextInlineStyle;
 exports.getDefaultTextLineStyle = getDefaultTextLineStyle;
 exports.getDefaultTextStyle = getDefaultTextStyle;
 exports.getDefaultTransformStyle = getDefaultTransformStyle;
+exports.isColor = isColor;
+exports.isGradient = isGradient;
 exports.isNone = isNone;
 exports.normalizeAudio = normalizeAudio;
 exports.normalizeBackground = normalizeBackground;
 exports.normalizeColor = normalizeColor;
+exports.normalizeColorFill = normalizeColorFill;
 exports.normalizeDocument = normalizeDocument;
 exports.normalizeEffect = normalizeEffect;
 exports.normalizeElement = normalizeElement;
 exports.normalizeFill = normalizeFill;
 exports.normalizeForeground = normalizeForeground;
-exports.normalizeGeometry = normalizeGeometry;
 exports.normalizeGradient = normalizeGradient;
+exports.normalizeGradientFill = normalizeGradientFill;
+exports.normalizeImageFill = normalizeImageFill;
 exports.normalizeInnerShadow = normalizeInnerShadow;
 exports.normalizeOuterShadow = normalizeOuterShadow;
 exports.normalizeOutline = normalizeOutline;
+exports.normalizePresetFill = normalizePresetFill;
 exports.normalizeShadow = normalizeShadow;
+exports.normalizeShape = normalizeShape;
 exports.normalizeSoftEdge = normalizeSoftEdge;
 exports.normalizeStyle = normalizeStyle;
 exports.normalizeText = normalizeText;
@@ -1152,4 +1204,5 @@ exports.normalizeTextContent = normalizeTextContent;
 exports.normalizeVideo = normalizeVideo;
 exports.parseColor = parseColor;
 exports.parseGradient = parseGradient;
+exports.round = round;
 exports.stringifyGradient = stringifyGradient;