modern-idoc 0.4.5 → 0.5.1

package/dist/index.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+const colord = require('colord');
+
 function normalizeAudio(audio) {
   if (!audio || audio === "none") {
     return void 0;
@@ -10,47 +12,147 @@ function normalizeAudio(audio) {
   }
 }
 
+function parseColor(color) {
+  let input;
+  if (typeof color === "number") {
+    input = {
+      r: color >> 24 & 255,
+      g: color >> 16 & 255,
+      b: color >> 8 & 255,
+      a: (color & 255) / 255
+    };
+  } else {
+    input = color;
+  }
+  return colord.colord(input);
+}
+function normalizeColor(color, orFail = false) {
+  if (color === void 0 || color === "none") {
+    return void 0;
+  }
+  const parsed = parseColor(color);
+  if (!parsed.isValid()) {
+    const message = `Failed to normalizeColor ${color}`;
+    if (orFail) {
+      throw new Error(message);
+    } else {
+      console.warn(message);
+      return `rgb(0, 0, 0)`;
+    }
+  }
+  return parsed.toRgbString();
+}
+
+function normalizeFill(fill) {
+  if (!fill || fill === "none") {
+    return void 0;
+  } else if (typeof fill === "string") {
+    return { color: normalizeColor(fill) };
+  } else {
+    return {
+      ...fill,
+      color: normalizeColor(fill.color)
+    };
+  }
+}
+
 function normalizeBackground(background) {
   if (!background || background === "none") {
     return void 0;
   } else if (typeof background === "string") {
     return { src: background };
   } else {
-    return background;
+    return {
+      ...background,
+      ...normalizeFill(background)
+    };
   }
 }
 
-function normalizeEffect(effect) {
-  if (!effect || effect === "none") {
-    return void 0;
-  } else {
-    return effect;
+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 getDefaultInnerShadow() {
+  return {
+    color: "rgb(0, 0, 0)",
+    offsetX: 0,
+    offsetY: 0,
+    blurRadius: 1
+  };
+}
 function normalizeInnerShadow(shadow) {
   if (!shadow || shadow === "none") {
     return void 0;
   } else {
-    return shadow;
+    return {
+      ...getDefaultInnerShadow(),
+      ...clearUndef({
+        ...shadow,
+        color: normalizeColor(shadow.color)
+      })
+    };
   }
 }
 
+function getDefaultOuterShadow() {
+  return {
+    ...getDefaultInnerShadow(),
+    scaleX: 1,
+    scaleY: 1
+  };
+}
 function normalizeOuterShadow(shadow) {
   if (!shadow || shadow === "none") {
     return void 0;
   } else {
-    return shadow;
+    return {
+      ...getDefaultOuterShadow(),
+      ...normalizeInnerShadow(shadow)
+    };
   }
 }
 
-function normalizeFill(fill) {
-  if (!fill || fill === "none") {
+function normalizeSoftEdge(softEdge) {
+  if (!softEdge || softEdge === "none") {
     return void 0;
-  } else if (typeof fill === "string") {
-    return { color: fill };
   } else {
-    return fill;
+    return softEdge;
+  }
+}
+
+function normalizeEffect(effect) {
+  if (!effect || effect === "none") {
+    return void 0;
+  } else {
+    return clearUndef({
+      ...effect,
+      softEdge: normalizeSoftEdge(effect.softEdge),
+      outerShadow: normalizeOuterShadow(effect.outerShadow),
+      innerShadow: normalizeInnerShadow(effect.innerShadow)
+    });
   }
 }
 
@@ -60,7 +162,10 @@ function normalizeForeground(foreground) {
   } else if (typeof foreground === "string") {
     return { src: foreground };
   } else {
-    return foreground;
+    return {
+      ...foreground,
+      ...normalizeFill(foreground)
+    };
   }
 }
 
@@ -94,149 +199,34 @@ function normalizeOutline(outline) {
     return void 0;
   } else if (typeof outline === "string") {
     return {
-      color: outline
+      color: normalizeColor(outline)
     };
   } else {
-    return outline;
+    return {
+      ...outline,
+      color: normalizeColor(outline.color)
+    };
   }
 }
 
-function getDefaultShadowStyle() {
-  return {
-    boxShadow: "none"
-  };
-}
 function normalizeShadow(shadow) {
   if (!shadow || shadow === "none") {
     return void 0;
   } else if (typeof shadow === "string") {
     return {
-      color: shadow
-    };
-  } else {
-    return shadow;
-  }
-}
-
-function normalizeTextContent(content = "") {
-  const list = Array.isArray(content) ? content : [content];
-  return list.map((p) => {
-    if (typeof p === "string") {
-      return {
-        fragments: [
-          { content: p }
-        ]
-      };
-    } else if ("content" in p) {
-      return {
-        fragments: [
-          { ...p }
-        ]
-      };
-    } else if ("fragments" in p) {
-      return {
-        ...p,
-        fragments: p.fragments.map((f) => ({ ...f }))
-      };
-    } else if (Array.isArray(p)) {
-      return {
-        fragments: p.map((f) => {
-          if (typeof f === "string") {
-            return {
-              content: f
-            };
-          } else {
-            return { ...f };
-          }
-        })
-      };
-    } else {
-      return {
-        fragments: []
-      };
-    }
-  });
-}
-function normalizeText(text) {
-  if (!text || text === "none") {
-    return void 0;
-  } else if (typeof text === "string") {
-    return {
-      content: [
-        {
-          fragments: [
-            { content: text }
-          ]
-        }
-      ]
-    };
-  } else if ("content" in text) {
-    return {
-      ...text,
-      content: normalizeTextContent(text.content)
+      color: normalizeColor(shadow)
     };
   } else {
     return {
-      content: normalizeTextContent(text)
+      ...shadow,
+      color: normalizeColor(shadow.color)
     };
   }
 }
-
-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 normalizeVideo(video) {
-  if (!video || video === "none") {
-    return void 0;
-  } else if (typeof video === "string") {
-    return { src: video };
-  } else {
-    return video;
-  }
-}
-
-function normalizeElement(element) {
-  return clearUndef({
-    ...element,
-    text: normalizeText(element.text),
-    background: normalizeBackground(element.background),
-    geometry: normalizeGeometry(element.geometry),
-    fill: normalizeFill(element.fill),
-    outline: normalizeOutline(element.outline),
-    foreground: normalizeForeground(element.foreground),
-    shadow: normalizeShadow(element.shadow),
-    video: normalizeVideo(element.video),
-    audio: normalizeVideo(element.audio),
-    effect: normalizeEffect(element.effect),
-    children: element.children?.map((child) => normalizeElement(child))
-  });
-}
-
-function normalizeDocument(doc) {
-  return normalizeElement(doc);
+function getDefaultShadowStyle() {
+  return {
+    boxShadow: "none"
+  };
 }
 
 function getDefaultLayoutStyle() {
@@ -321,7 +311,7 @@ function getDefaultElementStyle() {
     // outline
     outlineWidth: 0,
     outlineOffset: 0,
-    outlineColor: "#000000",
+    outlineColor: "rgb(0, 0, 0)",
     outlineStyle: "none",
     // other
     visibility: "visible",
@@ -334,6 +324,7 @@ function getDefaultElementStyle() {
 
 function getDefaultHighlightStyle() {
   return {
+    highlight: {},
     highlightImage: "none",
     highlightReferImage: "none",
     highlightColormap: "none",
@@ -345,6 +336,7 @@ function getDefaultHighlightStyle() {
 
 function getDefaultListStyleStyle() {
   return {
+    listStyle: {},
     listStyleType: "none",
     listStyleImage: "none",
     listStyleColormap: "none",
@@ -356,7 +348,7 @@ function getDefaultListStyleStyle() {
 function getDefaultTextInlineStyle() {
   return {
     ...getDefaultHighlightStyle(),
-    color: "black",
+    color: "rgb(0, 0, 0)",
     verticalAlign: "baseline",
     letterSpacing: 0,
     wordSpacing: 0,
@@ -390,10 +382,23 @@ function getDefaultTextStyle() {
     ...getDefaultTextInlineStyle(),
     // textStroke
     textStrokeWidth: 0,
-    textStrokeColor: "black"
+    textStrokeColor: "rgb(0, 0, 0)"
   };
 }
 
+function normalizeStyle(style) {
+  if (!style || style === "none") {
+    return void 0;
+  }
+  return clearUndef({
+    ...style,
+    color: normalizeColor(style.color),
+    backgroundColor: normalizeColor(style.backgroundColor),
+    borderColor: normalizeColor(style.borderColor),
+    outlineColor: normalizeColor(style.outlineColor),
+    shadowColor: normalizeColor(style.shadowColor)
+  });
+}
 function getDefaultStyle() {
   return {
     ...getDefaultElementStyle(),
@@ -401,11 +406,109 @@ function getDefaultStyle() {
   };
 }
 
+function normalizeTextContent(content = "") {
+  const list = Array.isArray(content) ? content : [content];
+  return list.map((p) => {
+    if (typeof p === "string") {
+      return {
+        fragments: [
+          { content: p }
+        ]
+      };
+    } else if ("content" in p) {
+      return {
+        fragments: [
+          normalizeStyle(p)
+        ]
+      };
+    } else if ("fragments" in p) {
+      return {
+        ...normalizeStyle(p),
+        fragments: p.fragments.map((f) => normalizeStyle(f))
+      };
+    } else if (Array.isArray(p)) {
+      return {
+        fragments: p.map((f) => {
+          if (typeof f === "string") {
+            return {
+              content: f
+            };
+          } else {
+            return normalizeStyle(f);
+          }
+        })
+      };
+    } else {
+      return {
+        fragments: []
+      };
+    }
+  });
+}
+function normalizeText(text) {
+  if (!text || text === "none") {
+    return void 0;
+  } else if (typeof text === "string") {
+    return {
+      content: [
+        {
+          fragments: [
+            { content: text }
+          ]
+        }
+      ]
+    };
+  } else if ("content" in text) {
+    return {
+      ...text,
+      content: normalizeTextContent(text.content)
+    };
+  } else {
+    return {
+      content: normalizeTextContent(text)
+    };
+  }
+}
+
+function normalizeVideo(video) {
+  if (!video || video === "none") {
+    return void 0;
+  } else if (typeof video === "string") {
+    return { src: video };
+  } else {
+    return video;
+  }
+}
+
+function normalizeElement(element) {
+  return clearUndef({
+    ...element,
+    style: normalizeStyle(element.style),
+    text: normalizeText(element.text),
+    background: normalizeBackground(element.background),
+    geometry: normalizeGeometry(element.geometry),
+    fill: normalizeFill(element.fill),
+    outline: normalizeOutline(element.outline),
+    foreground: normalizeForeground(element.foreground),
+    shadow: normalizeShadow(element.shadow),
+    video: normalizeVideo(element.video),
+    audio: normalizeAudio(element.audio),
+    effect: normalizeEffect(element.effect),
+    children: element.children?.map((child) => normalizeElement(child))
+  });
+}
+
+function normalizeDocument(doc) {
+  return normalizeElement(doc);
+}
+
 exports.clearUndef = clearUndef;
 exports.getDefaultElementStyle = getDefaultElementStyle;
 exports.getDefaultHighlightStyle = getDefaultHighlightStyle;
+exports.getDefaultInnerShadow = getDefaultInnerShadow;
 exports.getDefaultLayoutStyle = getDefaultLayoutStyle;
 exports.getDefaultListStyleStyle = getDefaultListStyleStyle;
+exports.getDefaultOuterShadow = getDefaultOuterShadow;
 exports.getDefaultShadowStyle = getDefaultShadowStyle;
 exports.getDefaultStyle = getDefaultStyle;
 exports.getDefaultTextInlineStyle = getDefaultTextInlineStyle;
@@ -414,6 +517,7 @@ exports.getDefaultTextStyle = getDefaultTextStyle;
 exports.getDefaultTransformStyle = getDefaultTransformStyle;
 exports.normalizeAudio = normalizeAudio;
 exports.normalizeBackground = normalizeBackground;
+exports.normalizeColor = normalizeColor;
 exports.normalizeDocument = normalizeDocument;
 exports.normalizeEffect = normalizeEffect;
 exports.normalizeElement = normalizeElement;
@@ -424,6 +528,9 @@ exports.normalizeInnerShadow = normalizeInnerShadow;
 exports.normalizeOuterShadow = normalizeOuterShadow;
 exports.normalizeOutline = normalizeOutline;
 exports.normalizeShadow = normalizeShadow;
+exports.normalizeSoftEdge = normalizeSoftEdge;
+exports.normalizeStyle = normalizeStyle;
 exports.normalizeText = normalizeText;
 exports.normalizeTextContent = normalizeTextContent;
 exports.normalizeVideo = normalizeVideo;
+exports.parseColor = parseColor;