modern-idoc 0.0.3 → 0.1.1

package/README.md

@@ -21,46 +21,68 @@
 ## Usage
 
 ```ts
-import type { IDOC } from 'modern-idoc'
+import type { IDOCDocument } from 'modern-idoc'
 
-const doc: IDOC = {
-  name: 'example.pptx',
+const pdf: IDOCDocument = {
   children: [
     {
-      name: 'ppt/slides/slide1.xml',
       style: {
-        width: 960,
-        height: 540,
-      },
-      meta: {
-        layout: 'ppt/slideLayous/slideLayout1.xml',
+        width: 300,
+        height: 600,
       },
       children: [
         {
-          type: 'image',
           style: {
-            left: 100,
-            top: 100,
-            width: 300,
-            height: 400,
+            rotate: 60,
+            width: 50,
+            height: 50,
           },
-          src: '/example.png',
+          image: '/example.png',
         },
         {
-          type: 'text',
           style: {
+            rotate: 40,
             left: 100,
             top: 100,
+            fontSize: 20,
+            color: '#FF00FF',
           },
-          content: 'TEXT',
+          text: 'test',
         },
         {
-          type: 'shape',
-          paths: [
-            { fill: '#000', data: 'M 0 0 L 100 100' },
+          style: {
+            left: 200,
+            top: 100,
+            width: 100,
+            height: 200,
+            fontSize: 22,
+          },
+          text: [
+            {
+              letterSpacing: 3,
+              fragments: [
+                {
+                  content: 'He',
+                  color: '#00FF00',
+                  fontSize: 12,
+                },
+                {
+                  content: 'llo',
+                  color: '#000000',
+                },
+              ],
+            },
+            {
+              content: ', ',
+              color: '#FF0000',
+            },
+            {
+              content: 'World!',
+              color: '#0000FF',
+            },
           ],
         },
-      ]
+      ],
     },
   ],
 }

package/dist/index.cjs

@@ -48,7 +48,6 @@ function getDefaultElementStyle() {
 
 function getDefaultTextStyle() {
   return {
-    ...getDefaultElementStyle(),
     writingMode: "horizontal-tb",
     verticalAlign: "baseline",
     lineHeight: 1.2,
@@ -78,15 +77,205 @@ function getDefaultTextStyle() {
     listStyleColormap: "none",
     listStyleSize: "cover",
     listStylePosition: "outside",
-    // listStyle
+    // highlight
     highlightImage: "none",
     highlightReferImage: "none",
     highlightColormap: "none",
     highlightLine: "none",
     highlightSize: "cover",
-    highlightThickness: "100%"
+    highlightThickness: "100%",
+    // transform
+    scaleX: 1,
+    scaleY: 1,
+    skewX: 0,
+    skewY: 0,
+    translateX: 0,
+    translateY: 0,
+    transform: "none",
+    transformOrigin: "50% 50%",
+    // shadow
+    shadowColor: "transparent",
+    shadowOffsetX: 0,
+    shadowOffsetY: 0,
+    shadowBlur: 0
+  };
+}
+
+function getDefaultStyle() {
+  return {
+    ...getDefaultElementStyle(),
+    ...getDefaultTextStyle()
+  };
+}
+
+function normalizeFill(fill) {
+  if (!fill || fill === "none") {
+    return void 0;
+  } else if (typeof fill === "string") {
+    return {
+      color: fill
+    };
+  } else {
+    return fill;
+  }
+}
+
+function normalizeGeometry(geometry) {
+  if (!geometry || geometry === "none") {
+    return void 0;
+  } else if (typeof geometry === "string") {
+    return {
+      data: [
+        { data: geometry }
+      ]
+    };
+  } else if (Array.isArray(geometry)) {
+    return {
+      data: geometry.map((data) => {
+        return {
+          data
+        };
+      })
+    };
+  } else {
+    return {
+      ...geometry,
+      data: geometry.data.map((data) => {
+        if (typeof data === "string") {
+          return {
+            data
+          };
+        }
+        return data;
+      })
+    };
+  }
+}
+
+function normalizeImage(image) {
+  if (!image || image === "none") {
+    return void 0;
+  } else if (typeof image === "string") {
+    return {
+      src: image
+    };
+  } else {
+    return image;
+  }
+}
+
+function normalizeStroke(stroke) {
+  if (!stroke || stroke === "none") {
+    return void 0;
+  } else if (typeof stroke === "string") {
+    return {
+      color: stroke
+    };
+  } else {
+    return stroke;
+  }
+}
+
+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)
+    };
+  } 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 {
+    ...element,
+    image: normalizeImage(element.image),
+    video: normalizeVideo(element.video),
+    text: normalizeText(element.text),
+    geometry: normalizeGeometry(element.geometry),
+    fill: normalizeFill(element.fill),
+    stroke: normalizeStroke(element.stroke),
+    children: element.children?.map((child) => normalizeElement(child))
   };
 }
 
 exports.getDefaultElementStyle = getDefaultElementStyle;
+exports.getDefaultStyle = getDefaultStyle;
 exports.getDefaultTextStyle = getDefaultTextStyle;
+exports.normalizeElement = normalizeElement;
+exports.normalizeFill = normalizeFill;
+exports.normalizeGeometry = normalizeGeometry;
+exports.normalizeImage = normalizeImage;
+exports.normalizeStroke = normalizeStroke;
+exports.normalizeText = normalizeText;
+exports.normalizeTextContent = normalizeTextContent;
+exports.normalizeVideo = normalizeVideo;

package/dist/index.d.cts

@@ -1,32 +1,27 @@
-interface IBackgroundStyle {
-    opacity: number;
+interface IDOCFillDeclaration {
+    color?: string;
+    image?: string;
+    opacity?: number;
 }
 
-interface IBackground extends Partial<IBackgroundStyle> {
-    src: string;
-}
-
-interface IImage extends IElement {
-    type: 'image';
-    src: string;
-}
+type IDOCFillProp = 'none' | string | IDOCFillDeclaration;
 
+type SVGPathData = string;
 type FillRule = 'nonzero' | 'evenodd';
 type StrokeLinecap = 'butt' | 'round' | 'square';
 type StrokeLinejoin = 'arcs' | 'bevel' | 'miter' | 'miter-clip' | 'round';
-interface IPathDrawStyle {
-    fill: string;
-    stroke: string;
+interface IDOCPath2DStyle {
+    [key: string]: any;
+    opacity: number;
+    visibility: string;
     shadowColor: string;
     shadowOffsetX: number;
     shadowOffsetY: number;
     shadowBlur: number;
-}
-interface IPathStyle extends IPathDrawStyle {
-    [key: string]: any;
+    fill: string;
     fillOpacity: number;
     fillRule: FillRule;
-    opacity: number;
+    stroke: string;
     strokeOpacity: number;
     strokeWidth: number;
     strokeLinecap: StrokeLinecap;
@@ -34,56 +29,43 @@ interface IPathStyle extends IPathDrawStyle {
     strokeMiterlimit: number;
     strokeDasharray: number[];
     strokeDashoffset: number;
-    visibility: string;
 }
-interface IPath extends Partial<IPathStyle> {
-    data: string;
+interface IDOCPath2D extends Partial<IDOCPath2DStyle> {
+    data: SVGPathData;
 }
+interface IDOCGeometryDeclaration {
+    data: (IDOCPath2D | SVGPathData)[];
+}
+
+type IDOCGeometryProp = 'none' | SVGPathData | SVGPathData[] | IDOCGeometryDeclaration;
 
-interface IShape extends IElement {
-    type: 'shape';
-    paths: IPath[];
+interface IDOCImageDeclaration {
+    src: string;
+    opacity?: number;
 }
 
-type Overflow = 'hidden' | 'visible';
-type Visibility = 'hidden' | 'visible';
-interface IElementStyle {
-    overflow: Overflow;
-    visibility: Visibility;
-    filter: string;
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-    rotate: number;
-    opacity: number;
-    marginLeft: number;
-    marginTop: number;
-    marginRight: number;
-    marginBottom: number;
-    paddingLeft: number;
-    paddingTop: number;
-    paddingRight: number;
-    paddingBottom: number;
-    scaleX: number;
-    scaleY: number;
-    skewX: number;
-    skewY: number;
-    translateX: number;
-    translateY: number;
-    transform: string;
-    transformOrigin: string;
-    backgroundImage: string;
-    backgroundColor: string;
-    shadowColor: string;
-    shadowOffsetX: number;
-    shadowOffsetY: number;
-    shadowBlur: number;
-    borderRadius: number;
-    borderColor: string;
-    borderWidth: number;
+type IDOCImageProp = 'none' | string | IDOCImageDeclaration;
+
+interface IDOCMetaProp {
+    [key: string]: any;
+}
+
+interface IDOCNode {
+    name?: string;
+    children?: IDOCNode[];
+    meta?: IDOCMetaProp;
 }
 
+interface IDOCStrokeDeclaration {
+    color?: string;
+    image?: string;
+    opacity?: number;
+}
+
+type IDOCStrokeProp = 'none' | string | IDOCStrokeDeclaration;
+
+type Overflow = 'hidden' | 'visible';
+type Visibility = 'hidden' | 'visible';
 type FontWeight = 'normal' | 'bold' | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
 type FontStyle = 'normal' | 'italic' | 'oblique' | `oblique ${string}`;
 type FontKerning = 'none' | 'auto' | 'normal';
@@ -100,15 +82,15 @@ type ListStyleImage = 'none' | string;
 type ListStyleColormap = 'none' | Record<string, string>;
 type ListStyleSize = 'cover' | Sizeable;
 type ListStylePosition = 'inside' | 'outside';
-interface ListStyle {
+interface IDOCListStyleDeclaration {
     type: ListStyleType;
     image: ListStyleImage;
     colormap: ListStyleColormap;
     size: ListStyleSize;
     position: ListStylePosition;
 }
-interface TextListStyle {
-    listStyle?: Partial<ListStyle>;
+interface IDOCListStyleStyleDeclaration {
+    listStyle?: Partial<IDOCListStyleDeclaration>;
     listStyleType: ListStyleType;
     listStyleImage: ListStyleImage;
     listStyleColormap: ListStyleColormap;
@@ -121,7 +103,7 @@ type HighlightReferImage = 'none' | string;
 type HighlightColormap = 'none' | Record<string, string>;
 type HighlightSize = 'cover' | Sizeable;
 type HighlightThickness = Sizeable;
-interface Highlight {
+interface IDOCHighlightDeclaration {
     image: HighlightImage;
     referImage: HighlightReferImage;
     colormap: HighlightColormap;
@@ -129,8 +111,8 @@ interface Highlight {
     size: HighlightSize;
     thickness: HighlightThickness;
 }
-interface TextHighlightStyle {
-    highlight?: Partial<Highlight>;
+interface IDOCHighlightStyleDeclaration {
+    highlight?: Partial<IDOCHighlightDeclaration>;
     highlightImage: HighlightImage;
     highlightReferImage: HighlightReferImage;
     highlightColormap: HighlightColormap;
@@ -138,14 +120,37 @@ interface TextHighlightStyle {
     highlightSize: HighlightSize;
     highlightThickness: HighlightThickness;
 }
-interface ITextLineStyle extends TextListStyle {
+interface IDCOShadowDeclaration {
+    color: string;
+    offsetX: number;
+    offsetY: number;
+    blur: number;
+}
+interface IDOCShadowStyleDeclaration {
+    shadow?: Partial<IDCOShadowDeclaration>;
+    shadowColor: string;
+    shadowOffsetX: number;
+    shadowOffsetY: number;
+    shadowBlur: number;
+}
+interface IDOCTransformStyleDeclaration {
+    scaleX: number;
+    scaleY: number;
+    skewX: number;
+    skewY: number;
+    translateX: number;
+    translateY: number;
+    transform: string;
+    transformOrigin: string;
+}
+interface IDOCTextLineStyleDeclaration extends IDOCListStyleStyleDeclaration {
     writingMode: WritingMode;
     textWrap: TextWrap;
     textAlign: TextAlign;
     textIndent: number;
     lineHeight: number;
 }
-interface ITextInlineStyle extends TextHighlightStyle {
+interface IDOCTextInlineStyleDeclaration extends IDOCHighlightStyleDeclaration {
     color: string;
     verticalAlign: VerticalAlign;
     letterSpacing: number;
@@ -159,59 +164,113 @@ interface ITextInlineStyle extends TextHighlightStyle {
     textOrientation: TextOrientation;
     textDecoration: TextDecorationLine;
 }
-interface ITextDrawStyle {
+interface IDOCTextDrawStyleDeclaration extends IDOCShadowStyleDeclaration, IDOCTransformStyleDeclaration {
     textStrokeWidth: number;
     textStrokeColor: string;
-    shadowColor: string;
-    shadowOffsetX: number;
-    shadowOffsetY: number;
-    shadowBlur: number;
-    translateX: number;
-    translateY: number;
-    skewX: number;
-    skewY: number;
 }
-interface ITextStyle extends ITextLineStyle, ITextInlineStyle, ITextDrawStyle, IElementStyle {
+interface IDOCTextStyleDeclaration extends IDOCTextLineStyleDeclaration, IDOCTextInlineStyleDeclaration, IDOCTextDrawStyleDeclaration {
+}
+interface IDOCElementStyleDeclaration extends IDOCShadowStyleDeclaration, IDOCTransformStyleDeclaration {
+    overflow: Overflow;
+    visibility: Visibility;
+    filter: string;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    rotate: number;
+    opacity: number;
+    marginLeft: number;
+    marginTop: number;
+    marginRight: number;
+    marginBottom: number;
+    paddingLeft: number;
+    paddingTop: number;
+    paddingRight: number;
+    paddingBottom: number;
+    backgroundImage: string;
+    backgroundColor: string;
+    borderRadius: number;
+    borderColor: string;
+    borderWidth: number;
+}
+interface IDOCStyleDeclaration extends IDOCTextStyleDeclaration, IDOCElementStyleDeclaration {
 }
 
-interface IFragmentContent extends Partial<ITextStyle> {
+type IDOCStyleProp = Partial<IDOCStyleDeclaration>;
+
+interface IDOCFragmentContent extends Partial<IDOCStyleDeclaration> {
     content: string;
 }
-interface IParagraphContent extends Partial<ITextStyle> {
-    fragments: IFragmentContent[];
+interface IDOCParagraphContent extends Partial<IDOCStyleDeclaration> {
+    fragments: IDOCFragmentContent[];
 }
-type ITextContent = string | IFragmentContent | IParagraphContent | (string | IFragmentContent | IParagraphContent | (string | IFragmentContent)[])[];
-interface IText extends IElement<ITextStyle> {
-    type: 'text';
-    content: ITextContent;
-    effects?: Partial<ITextStyle>[];
+type IDOCTextContentFlat = string | IDOCFragmentContent | IDOCParagraphContent | (string | IDOCFragmentContent)[];
+type IDOCTextContent = string | IDOCFragmentContent | IDOCParagraphContent | IDOCTextContentFlat[];
+type IDOCTextContentDeclaration = IDOCParagraphContent[];
+interface IDOCTextDeclaration {
+    content: IDOCTextContentDeclaration;
+    effects?: Partial<IDOCStyleDeclaration>[];
     measureDom?: any;
     fonts?: any;
 }
 
-interface IVideo extends IElement {
-    type: 'video';
+type IDOCTextProp = string | IDOCTextContent | (IDOCTextDeclaration & {
+    content: IDOCTextContent;
+}) | IDOCTextDeclaration;
+
+interface IDOCVideoDeclaration {
     src: string;
+    opacity?: number;
 }
 
-type IElementChild = IElement | IImage | IText | IVideo | IShape;
-
-type IElementMeta = Record<string, any>;
+type IDOCVideoProp = 'none' | string | IDOCVideoDeclaration;
 
-interface IElement<T = IElementStyle> {
-    name?: string;
-    style?: Partial<T>;
-    background?: IBackground;
-    meta?: IElementMeta;
-    children?: IElementChild[];
+interface IDOCElement extends IDOCNode {
+    style?: IDOCStyleProp;
+    image?: IDOCImageProp;
+    video?: IDOCVideoProp;
+    text?: IDOCTextProp;
+    geometry?: IDOCGeometryProp;
+    fill?: IDOCFillProp;
+    stroke?: IDOCStrokeProp;
+    children?: IDOCElement[];
 }
 
-interface IDOC extends IElement {
+interface IDOCDocument extends IDOCElement {
     fonts?: any;
 }
 
-declare function getDefaultElementStyle(): IElementStyle;
+interface IDOCElementDeclaration extends IDOCElement {
+    image?: IDOCImageDeclaration;
+    video?: IDOCVideoDeclaration;
+    text?: IDOCTextDeclaration;
+    geometry?: IDOCGeometryDeclaration;
+    fill?: IDOCFillDeclaration;
+    stroke?: IDOCStrokeDeclaration;
+    children?: IDOCElementDeclaration[];
+}
+
+declare function getDefaultElementStyle(): IDOCElementStyleDeclaration;
+
+declare function getDefaultStyle(): IDOCStyleDeclaration;
+
+declare function getDefaultTextStyle(): IDOCTextStyleDeclaration;
+
+declare function normalizeElement(element: IDOCElement): IDOCElementDeclaration;
+
+declare function normalizeFill(fill?: IDOCFillProp): IDOCFillDeclaration | undefined;
+
+declare function normalizeGeometry(geometry?: IDOCGeometryProp): IDOCGeometryDeclaration | undefined;
+
+declare function normalizeImage(image?: IDOCImageProp): IDOCImageDeclaration | undefined;
+
+declare function normalizeStroke(stroke?: IDOCStrokeProp): IDOCStrokeDeclaration | undefined;
+
+declare function normalizeText(text?: IDOCTextProp): IDOCTextDeclaration | undefined;
+
+declare function normalizeTextContent(content?: IDOCTextContent): IDOCTextContentDeclaration;
 
-declare function getDefaultTextStyle(): ITextStyle;
+declare function normalizeVideo(video?: IDOCVideoProp): IDOCVideoDeclaration | undefined;
 
-export { type FillRule, type FontKerning, type FontStyle, type FontWeight, type Highlight, type HighlightColormap, type HighlightImage, type HighlightLine, type HighlightReferImage, type HighlightSize, type HighlightThickness, type IBackground, type IBackgroundStyle, type IDOC, type IElement, type IElementChild, type IElementMeta, type IElementStyle, type IFragmentContent, type IImage, type IParagraphContent, type IPath, type IPathDrawStyle, type IPathStyle, type IShape, type IText, type ITextContent, type ITextDrawStyle, type ITextInlineStyle, type ITextLineStyle, type ITextStyle, type IVideo, type ListStyle, type ListStyleColormap, type ListStyleImage, type ListStylePosition, type ListStyleSize, type ListStyleType, type Overflow, type Sizeable, type StrokeLinecap, type StrokeLinejoin, type TextAlign, type TextDecorationLine, type TextHighlightStyle, type TextListStyle, type TextOrientation, type TextTransform, type TextWrap, type VerticalAlign, type Visibility, type WritingMode, getDefaultElementStyle, getDefaultTextStyle };
+export { type FillRule, type FontKerning, type FontStyle, type FontWeight, type HighlightColormap, type HighlightImage, type HighlightLine, type HighlightReferImage, type HighlightSize, type HighlightThickness, type IDCOShadowDeclaration, type IDOCDocument, type IDOCElement, type IDOCElementDeclaration, type IDOCElementStyleDeclaration, type IDOCFillDeclaration, type IDOCFillProp, type IDOCFragmentContent, type IDOCGeometryDeclaration, type IDOCGeometryProp, type IDOCHighlightDeclaration, type IDOCHighlightStyleDeclaration, type IDOCImageDeclaration, type IDOCImageProp, type IDOCListStyleDeclaration, type IDOCListStyleStyleDeclaration, type IDOCMetaProp, type IDOCNode, type IDOCParagraphContent, type IDOCPath2D, type IDOCPath2DStyle, type IDOCShadowStyleDeclaration, type IDOCStrokeDeclaration, type IDOCStrokeProp, type IDOCStyleDeclaration, type IDOCStyleProp, type IDOCTextContent, type IDOCTextContentDeclaration, type IDOCTextContentFlat, type IDOCTextDeclaration, type IDOCTextDrawStyleDeclaration, type IDOCTextInlineStyleDeclaration, type IDOCTextLineStyleDeclaration, type IDOCTextProp, type IDOCTextStyleDeclaration, type IDOCTransformStyleDeclaration, type IDOCVideoDeclaration, type IDOCVideoProp, type ListStyleColormap, type ListStyleImage, type ListStylePosition, type ListStyleSize, type ListStyleType, type Overflow, type SVGPathData, type Sizeable, type StrokeLinecap, type StrokeLinejoin, type TextAlign, type TextDecorationLine, type TextOrientation, type TextTransform, type TextWrap, type VerticalAlign, type Visibility, type WritingMode, getDefaultElementStyle, getDefaultStyle, getDefaultTextStyle, normalizeElement, normalizeFill, normalizeGeometry, normalizeImage, normalizeStroke, normalizeText, normalizeTextContent, normalizeVideo };