import { BuilderElement, XmlComponent, createVmlShape, hashedId, standardizeData, uniqueId } from "docx";
//#region src/watermarks/vml/pict.ts
/**
* The picture element (`w:pict`) that holds a watermark's VML shape type and shape.
*
* @module
*/
/**
* Creates a `w:pict` element holding VML content, such as a `v:shapetype` followed by the `v:shape` that uses it.
*
* ```xml
*
* ```
*/
var createPict = ({ children }) => new BuilderElement({
name: "w:pict",
children
});
//#endregion
//#region src/watermarks/vml/vml-values.ts
/**
* Converts a boolean into the VML `t`/`f` representation.
*
* Undefined values are passed through so that optional attributes are omitted
* from the generated XML.
*
* @param value - The boolean to convert
* @returns `"t"` for true, `"f"` for false, or `undefined` when no value was given
*
* @example
* ```typescript
* vmlTrueFalse(true); // "t"
* vmlTrueFalse(false); // "f"
* vmlTrueFalse(undefined); // undefined
* ```
*/
var vmlTrueFalse = (value) => value === void 0 ? void 0 : value ? "t" : "f";
/**
* Normalizes a colour for VML colour attributes (ST_ColorType).
*
* VML accepts either a named colour (`silver`, `red`, ...) or a hex triplet
* prefixed with `#`. Hex values are accepted with or without the leading `#`
* and are always emitted with it so that Word does not mistake them for
* colour names. Any other value is passed through unchanged.
*
* @param value - A named colour, or a 6-digit hex colour with or without `#`
* @returns The colour formatted for VML
*
* @example
* ```typescript
* vmlColorValue("C0C0C0"); // "#C0C0C0"
* vmlColorValue("#ff0000"); // "#ff0000"
* vmlColorValue("silver"); // "silver"
* ```
*/
var vmlColorValue = (value) => /^#?[0-9a-fA-F]{6}$/.test(value) ? `#${value.replace(/^#/, "")}` : value;
/**
* Formats a fraction as a VML fixed-point value.
*
* Several VML attributes (`gain`, `blacklevel`, ...) accept fixed-point
* numbers where 65536 represents 1.0. These are written with an `f` suffix.
*
* @param value - The fraction to convert, where 1 represents 65536
* @returns The fixed-point representation, e.g. `"19661f"`
*
* @example
* ```typescript
* vmlFixedPoint(0.5); // "32768f"
* ```
*/
var vmlFixedPoint = (value) => `${Math.round(value * 65536)}f`;
//#endregion
//#region src/watermarks/vml/vml-fill.ts
/**
* VML fill module for WordprocessingML documents.
*
* Provides functionality for describing how the interior of a VML shape is painted.
*
* Reference: http://webapp.docx4java.org/OnlineDemo/ecma376/VML/fill.html
*
* @module
*/
/**
* Creates a VML fill element.
*
* The VML fill element (v:fill) refines the fill of its parent shape, for example
* to make a watermark semi-transparent.
*
* ## XSD Schema
* ```xml
*
*
*
*
*
*
*
*
*
*
*
*
*
* ```
*
* @param options - Configuration options for the fill
* @returns An XmlComponent representing the v:fill element
*
* @example
* ```typescript
* createVmlFill({ opacity: 0.5 });
* //
* ```
*/
var createVmlFill = ({ on, type, color, color2, opacity, angle } = {}) => new BuilderElement({
name: "v:fill",
attributes: {
on: {
key: "on",
value: vmlTrueFalse(on)
},
type: {
key: "type",
value: type
},
color: {
key: "color",
value: color
},
color2: {
key: "color2",
value: color2
},
opacity: {
key: "opacity",
value: opacity
},
angle: {
key: "angle",
value: angle
}
}
});
//#endregion
//#region src/watermarks/vml/vml-text-path.ts
/**
* VML text path module for WordprocessingML documents.
*
* A text path renders text along, or stretched into, the geometry of a shape. It is
* the mechanism behind WordArt and text watermarks.
*
* Reference: http://webapp.docx4java.org/OnlineDemo/ecma376/VML/textpath.html
*
* @module
*/
/**
* Formats a VmlTextPathStyle object into the CSS-like string used by the text path `style` attribute.
*
* @param style - The style to format
* @returns The formatted style, or undefined when no properties were set
*
* @example
* ```typescript
* formatVmlTextPathStyle({ fontFamily: "Calibri", fontSize: 1 });
* // 'font-family:"Calibri";font-size:1pt'
* ```
*/
var formatVmlTextPathStyle = ({ fontFamily, fontSize, fontWeight, fontStyle, textAlign, sameLetterHeights } = {}) => {
const properties = [
fontFamily === void 0 ? void 0 : `font-family:"${fontFamily}"`,
fontSize === void 0 ? void 0 : `font-size:${fontSize}pt`,
fontWeight === void 0 ? void 0 : `font-weight:${fontWeight}`,
fontStyle === void 0 ? void 0 : `font-style:${fontStyle}`,
textAlign === void 0 ? void 0 : `v-text-align:${textAlign}`,
sameLetterHeights === void 0 ? void 0 : `v-same-letter-heights:${vmlTrueFalse(sameLetterHeights)}`
].filter((property) => property !== void 0);
return properties.length ? properties.join(";") : void 0;
};
/**
* Creates a VML text path element.
*
* The VML text path element (v:textpath) renders text using the geometry of its
* parent shape. On a shape type it declares that shapes of that type carry text; on
* a shape it supplies the actual text and its styling.
*
* ## XSD Schema
* ```xml
*
*
*
*
*
*
*
*
*
*
* ```
*
* @param options - Configuration options for the text path
* @returns An XmlComponent representing the v:textpath element
*
* @example
* ```typescript
* createVmlTextPath({ text: "DRAFT", style: { fontFamily: "Calibri", fontSize: 1 } });
* //
* ```
*/
var createVmlTextPath = ({ on, fitShape, fitPath, trim, xScale, text, style } = {}) => new BuilderElement({
name: "v:textpath",
attributes: {
on: {
key: "on",
value: vmlTrueFalse(on)
},
fitShape: {
key: "fitshape",
value: vmlTrueFalse(fitShape)
},
fitPath: {
key: "fitpath",
value: vmlTrueFalse(fitPath)
},
trim: {
key: "trim",
value: vmlTrueFalse(trim)
},
xScale: {
key: "xscale",
value: vmlTrueFalse(xScale)
},
style: {
key: "style",
value: formatVmlTextPathStyle(style)
},
text: {
key: "string",
value: text
}
}
});
//#endregion
//#region src/watermarks/vml/vml-formulas.ts
/**
* VML formulas module for WordprocessingML documents.
*
* Formulas compute the guide values (`@0`, `@1`, ...) that a shape's path and
* handles refer to, allowing the geometry to respond to adjustment values.
*
* Reference: http://webapp.docx4java.org/OnlineDemo/ecma376/VML/formulas.html
*
* @module
*/
/**
* Creates a single VML formula element.
*
* ## XSD Schema
* ```xml
*
*
*
* ```
*
* @param equation - The equation, e.g. `sum #0 0 10800`
* @returns An XmlComponent representing the v:f element
*/
var createVmlFormula = (equation) => new BuilderElement({
name: "v:f",
attributes: { equation: {
key: "eqn",
value: equation
} }
});
/**
* Creates a VML formulas element containing one formula per equation.
*
* ## XSD Schema
* ```xml
*
*
*
*
*
* ```
*
* @param equations - The equations, in order. Each is referenced by its index as `@n`.
* @returns An XmlComponent representing the v:formulas element
*
* @example
* ```typescript
* createVmlFormulas(["sum #0 0 10800", "prod #0 2 1"]);
* //
* ```
*/
var createVmlFormulas = (equations) => new BuilderElement({
name: "v:formulas",
children: equations.map(createVmlFormula)
});
//#endregion
//#region src/watermarks/vml/vml-handles.ts
/**
* VML handles module for WordprocessingML documents.
*
* Handles are the draggable points that let a user change a shape's adjustment
* values in an editor.
*
* Reference: http://webapp.docx4java.org/OnlineDemo/ecma376/VML/handles.html
*
* @module
*/
/**
* Creates a single VML handle element.
*
* ## XSD Schema
* ```xml
*
*
*
*
*
*
*
*
*
*
*
* ```
*
* @param options - Configuration options for the handle
* @returns An XmlComponent representing the v:h element
*/
var createVmlHandle = ({ position, xRange, yRange }) => new BuilderElement({
name: "v:h",
attributes: {
position: {
key: "position",
value: position
},
xRange: {
key: "xrange",
value: xRange
},
yRange: {
key: "yrange",
value: yRange
}
}
});
/**
* Creates a VML handles element containing one handle per option.
*
* ## XSD Schema
* ```xml
*
*
*
*
*
* ```
*
* @param handles - The handles, in order
* @returns An XmlComponent representing the v:handles element
*
* @example
* ```typescript
* createVmlHandles([{ position: "#0,bottomRight", xRange: "6629,14971" }]);
* //
* ```
*/
var createVmlHandles = (handles) => new BuilderElement({
name: "v:handles",
children: handles.map(createVmlHandle)
});
//#endregion
//#region src/watermarks/vml/vml-lock.ts
/**
* VML lock module for WordprocessingML documents.
*
* A lock prevents particular kinds of edits to a shape in an editor, for example
* keeping a picture's aspect ratio or stopping WordArt text from being edited.
*
* Reference: http://webapp.docx4java.org/OnlineDemo/ecma376/VML/lock.html
*
* @module
*/
/**
* Creates a VML lock element.
*
* ## XSD Schema
* ```xml
*
*
*
*
*
*
*
*
*
*
*
*
*
*
* ```
*
* @param options - Configuration options for the lock
* @returns An XmlComponent representing the o:lock element
*
* @example
* ```typescript
* createVmlLock({ aspectRatio: true });
* //
* ```
*/
var createVmlLock = ({ extension = "edit", position, selection, grouping, ungrouping, rotation, cropping, vertices, adjustHandles, text, aspectRatio, shapeType } = {}) => new BuilderElement({
name: "o:lock",
attributes: {
extension: {
key: "v:ext",
value: extension
},
position: {
key: "position",
value: vmlTrueFalse(position)
},
selection: {
key: "selection",
value: vmlTrueFalse(selection)
},
grouping: {
key: "grouping",
value: vmlTrueFalse(grouping)
},
ungrouping: {
key: "ungrouping",
value: vmlTrueFalse(ungrouping)
},
rotation: {
key: "rotation",
value: vmlTrueFalse(rotation)
},
cropping: {
key: "cropping",
value: vmlTrueFalse(cropping)
},
vertices: {
key: "verticies",
value: vmlTrueFalse(vertices)
},
adjustHandles: {
key: "adjusthandles",
value: vmlTrueFalse(adjustHandles)
},
text: {
key: "text",
value: vmlTrueFalse(text)
},
aspectRatio: {
key: "aspectratio",
value: vmlTrueFalse(aspectRatio)
},
shapeType: {
key: "shapetype",
value: vmlTrueFalse(shapeType)
}
}
});
//#endregion
//#region src/watermarks/vml/vml-path.ts
/**
* VML path module for WordprocessingML documents.
*
* The path element refines the geometry declared on a shape or shape type: which
* features (text, fill, gradients) the geometry supports and where connectors attach.
*
* Reference: http://webapp.docx4java.org/OnlineDemo/ecma376/VML/path.html
*
* @module
*/
/**
* Creates a VML path element.
*
* ## XSD Schema
* ```xml
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
* ```
*
* @param options - Configuration options for the path
* @returns An XmlComponent representing the v:path element
*
* @example
* ```typescript
* createVmlPath({ textPathOk: true, connectType: "custom" });
* //
* ```
*/
var createVmlPath = ({ value, fillOk, strokeOk, shadowOk, arrowOk, gradientShapeOk, textPathOk, extrusionOk, connectType, connectLocations, connectAngles } = {}) => new BuilderElement({
name: "v:path",
attributes: {
value: {
key: "v",
value
},
fillOk: {
key: "fillok",
value: vmlTrueFalse(fillOk)
},
strokeOk: {
key: "strokeok",
value: vmlTrueFalse(strokeOk)
},
shadowOk: {
key: "shadowok",
value: vmlTrueFalse(shadowOk)
},
arrowOk: {
key: "arrowok",
value: vmlTrueFalse(arrowOk)
},
gradientShapeOk: {
key: "gradientshapeok",
value: vmlTrueFalse(gradientShapeOk)
},
textPathOk: {
key: "textpathok",
value: vmlTrueFalse(textPathOk)
},
extrusionOk: {
key: "o:extrusionok",
value: vmlTrueFalse(extrusionOk)
},
connectType: {
key: "o:connecttype",
value: connectType
},
connectLocations: {
key: "o:connectlocs",
value: connectLocations
},
connectAngles: {
key: "o:connectangles",
value: connectAngles
}
}
});
//#endregion
//#region src/watermarks/vml/vml-shape-type.ts
/**
* VML shape type module for WordprocessingML documents.
*
* A shape type defines reusable geometry (path, formulas, handles and default
* properties) that shapes reference through their `type` attribute. Word emits a
* shape type for each kind of VML shape it uses, such as text boxes, WordArt or
* picture frames.
*
* Reference: http://webapp.docx4java.org/OnlineDemo/ecma376/VML/shapetype.html
*
* @module
*/
/**
* Creates a VML shape type element.
*
* The VML shape type element (v:shapetype) declares geometry and defaults that
* can be shared by several shapes.
*
* ## XSD Schema
* ```xml
*
*
*
*
*
*
*
*
*
*
*
* ```
*
* @param options - Configuration options for the shape type
* @returns An XmlComponent representing the v:shapetype element
*
* @example
* ```typescript
* const shapeType = createVmlShapeType({
* id: "_x0000_t136",
* coordinateSize: "21600,21600",
* presetShapeType: 136,
* adjustment: "10800",
* path: "m@7,l@8,m@5,21600l@6,21600e",
* });
* ```
*/
var createVmlShapeType = ({ id, coordinateSize, presetShapeType, preferRelative, adjustment, path, filled, stroked, children = [] }) => new BuilderElement({
name: "v:shapetype",
attributes: {
id: {
key: "id",
value: id
},
coordinateSize: {
key: "coordsize",
value: coordinateSize
},
presetShapeType: {
key: "o:spt",
value: presetShapeType
},
preferRelative: {
key: "o:preferrelative",
value: vmlTrueFalse(preferRelative)
},
adjustment: {
key: "adj",
value: adjustment
},
path: {
key: "path",
value: path
},
filled: {
key: "filled",
value: vmlTrueFalse(filled)
},
stroked: {
key: "stroked",
value: vmlTrueFalse(stroked)
}
},
children
});
//#endregion
//#region src/watermarks/vml/word-art-shape-type.ts
/** Identifier of the WordArt (plain text) shape type. Shapes reference it as `#_x0000_t136`. */
var WORD_ART_SHAPE_TYPE_ID = "_x0000_t136";
/** Office preset shape number for plain WordArt text. */
var WORD_ART_PRESET_SHAPE_TYPE = 136;
/**
* Creates the WordArt (plain text) shape type as emitted by Microsoft Word.
*
* The resulting shape type has the identifier `_x0000_t136`. Shapes using it must
* set `type: "#_x0000_t136"` and supply a `v:textpath` child carrying the text.
*
* @returns An XmlComponent representing the v:shapetype element
*
* @example
* ```typescript
* createPict({
* children: [
* createWordArtShapeType(),
* createVmlShape({
* id: "watermark",
* type: `#${WORD_ART_SHAPE_TYPE_ID}`,
* children: [createVmlTextPath({ text: "DRAFT" })],
* }),
* ],
* });
* ```
*/
var createWordArtShapeType = () => createVmlShapeType({
id: WORD_ART_SHAPE_TYPE_ID,
coordinateSize: "21600,21600",
presetShapeType: WORD_ART_PRESET_SHAPE_TYPE,
adjustment: "10800",
path: "m@7,l@8,m@5,21600l@6,21600e",
children: [
createVmlFormulas([
"sum #0 0 10800",
"prod #0 2 1",
"sum 21600 0 @1",
"sum 0 0 @2",
"sum 21600 0 @3",
"if @0 @3 0",
"if @0 21600 @1",
"if @0 0 @2",
"if @0 @4 21600",
"mid @5 @6",
"mid @8 @5",
"mid @7 @8",
"mid @6 @7",
"sum @6 0 @5"
]),
createVmlPath({
textPathOk: true,
connectType: "custom",
connectLocations: "@9,0;@10,10800;@11,21600;@12,10800",
connectAngles: "270,180,90,0"
}),
createVmlTextPath({
on: true,
fitShape: true
}),
createVmlHandles([{
position: "#0,bottomRight",
xRange: "6629,14971"
}]),
createVmlLock({
text: true,
shapeType: true
})
]
});
//#endregion
//#region src/watermarks/watermark-shape-style.ts
/**
* Z-order used by Word for watermarks. Negative values place the shape behind the text.
*/
var WATERMARK_Z_INDEX = -251657216;
/**
* Builds the VML shape style shared by watermarks.
*
* The shape is absolutely positioned, centred horizontally and vertically
* relative to the page margins, and placed behind the document text.
*
* @param options - Size and rotation of the watermark
* @returns The VML shape style
*
* @example
* ```typescript
* createWatermarkShapeStyle({ width: 527.85, height: 131.95, rotation: 315 });
* ```
*/
var createWatermarkShapeStyle = ({ width, height, rotation }) => ({
position: "absolute",
marginLeft: 0,
marginTop: 0,
width: `${width}pt`,
height: `${height}pt`,
rotation: rotation || void 0,
zIndex: WATERMARK_Z_INDEX,
positionHorizontal: "center",
positionHorizontalRelative: "margin",
positionVertical: "center",
positionVerticalRelative: "margin"
});
//#endregion
//#region src/watermarks/text-watermark.ts
/**
* Text watermark module for WordprocessingML documents.
*
* A text watermark is faint text, such as "DRAFT" or "CONFIDENTIAL", drawn behind
* the content of every page. Word implements it as a WordArt shape placed in the
* page header, and this module produces the same markup.
*
* Reference: https://support.microsoft.com/en-us/office/insert-a-watermark-c0ec3d5a-6f3e-4f3c-a8b0-9d9a6f56d3fd
*
* @module
*/
/**
* Prefix Word gives to text watermark shapes. Word's "Remove Watermark"
* command finds watermarks by this prefix.
*/
var TEXT_WATERMARK_ID_PREFIX = "PowerPlusWaterMarkObject";
/** Word's default watermark font. */
var DEFAULT_FONT = "Calibri";
/** Word's default watermark colour. */
var DEFAULT_COLOR = "silver";
/** Word's default "semitransparent" watermark opacity. */
var DEFAULT_OPACITY = .5;
/** Width Word gives an automatically sized watermark, in points. */
var DEFAULT_WIDTH = 527.85;
/** Rotation Word applies to a diagonal watermark, in degrees clockwise. */
var DIAGONAL_ROTATION = 315;
/**
* Font size written for automatically sized text. Word stretches the text to
* fill the shape regardless of the font size, and writes 1pt to mean "auto".
*/
var AUTO_FONT_SIZE = 1;
/**
* Approximate width of an uppercase letter relative to the height of the shape,
* used to derive a default shape height that keeps the letters in proportion.
*/
var CHARACTER_ASPECT_RATIO = .8;
/** Approximate width of a space relative to the height of the shape. */
var SPACE_ASPECT_RATIO = .35;
/**
* Estimates a shape height that keeps the text in proportion for the given width.
*
* Word stretches watermark text to fill the shape, so the shape's aspect ratio
* must roughly match the text's. Font metrics are not available here, so the
* width of each character is approximated as a fraction of the height.
*
* @param text - The watermark text
* @param width - The width of the shape in points
* @returns The estimated height in points, never larger than the width
*/
var estimateHeight = (text, width) => {
const aspectRatio = [...text].reduce((total, character) => total + (character === " " ? SPACE_ASPECT_RATIO : CHARACTER_ASPECT_RATIO), 0);
return Math.round(width / Math.max(aspectRatio, 1) * 100) / 100;
};
/**
* Represents a text watermark in a WordprocessingML document.
*
* TextWatermark is an inline element that belongs inside a paragraph, and the
* paragraph belongs in a header so that the watermark repeats on every page of
* the section. It renders as a WordArt shape centred on the page behind the
* document text, exactly as Word's Design > Watermark command does, so Word
* recognizes it and can remove or replace it through that command.
*
* @publicApi
*
* ## XSD Schema
* The watermark combines several elements:
* - w:r (run container)
* - w:pict (picture element containing VML)
* - v:shapetype (WordArt shape type definition)
* - v:shape (the positioned WordArt shape)
* - v:fill (opacity)
* - v:textpath (the text and its font)
*
* @example
* ```typescript
* new Document({
* sections: [
* {
* headers: {
* default: new Header({
* children: [new Paragraph({ children: [new TextWatermark({ text: "DRAFT" })] })],
* }),
* },
* children: [new Paragraph("Body text")],
* },
* ],
* });
*
* // Customised watermark
* new TextWatermark({
* text: "CONFIDENTIAL",
* font: "Arial",
* color: "FF0000",
* opacity: 0.3,
* layout: "horizontal",
* });
* ```
*/
var TextWatermark = class extends XmlComponent {
constructor({ text, font = DEFAULT_FONT, fontSize = AUTO_FONT_SIZE, bold, italics, color = DEFAULT_COLOR, opacity = DEFAULT_OPACITY, layout = "diagonal", rotation = layout === "diagonal" ? DIAGONAL_ROTATION : 0, width = DEFAULT_WIDTH, height = estimateHeight(text, width) }) {
super("w:r");
this.root.push(createPict({ children: [createWordArtShapeType(), createVmlShape({
id: `${TEXT_WATERMARK_ID_PREFIX}${uniqueId()}`,
type: `#${WORD_ART_SHAPE_TYPE_ID}`,
style: createWatermarkShapeStyle({
width,
height,
rotation
}),
allowInCell: false,
fillColor: vmlColorValue(color),
stroked: false,
children: [createVmlFill({ opacity }), createVmlTextPath({
text,
style: {
fontFamily: font,
fontSize,
fontWeight: bold ? "bold" : void 0,
fontStyle: italics ? "italic" : void 0
}
})]
})] }));
}
};
//#endregion
//#region src/watermarks/vml/vml-stroke.ts
/**
* VML stroke module for WordprocessingML documents.
*
* Provides functionality for describing how the outline of a VML shape is drawn.
*
* Reference: http://webapp.docx4java.org/OnlineDemo/ecma376/VML/stroke.html
*
* @module
*/
/**
* Creates a VML stroke element.
*
* The VML stroke element (v:stroke) refines the outline of its parent shape.
*
* ## XSD Schema
* ```xml
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
* ```
*
* @param options - Configuration options for the stroke
* @returns An XmlComponent representing the v:stroke element
*
* @example
* ```typescript
* createVmlStroke({ joinStyle: "miter" });
* //
* ```
*/
var createVmlStroke = ({ on, weight, color, opacity, joinStyle } = {}) => new BuilderElement({
name: "v:stroke",
attributes: {
on: {
key: "on",
value: vmlTrueFalse(on)
},
weight: {
key: "weight",
value: weight
},
color: {
key: "color",
value: color
},
opacity: {
key: "opacity",
value: opacity
},
joinStyle: {
key: "joinstyle",
value: joinStyle
}
}
});
//#endregion
//#region src/watermarks/vml/picture-frame-shape-type.ts
/** Identifier of the picture frame shape type. Shapes reference it as `#_x0000_t75`. */
var PICTURE_FRAME_SHAPE_TYPE_ID = "_x0000_t75";
/** Office preset shape number for a picture frame. */
var PICTURE_FRAME_PRESET_SHAPE_TYPE = 75;
/**
* Creates the picture frame shape type as emitted by Microsoft Word.
*
* The resulting shape type has the identifier `_x0000_t75`. Shapes using it must
* set `type: "#_x0000_t75"` and supply a `v:imagedata` child referencing the image.
*
* @returns An XmlComponent representing the v:shapetype element
*
* @example
* ```typescript
* createPict({
* children: [
* createPictureFrameShapeType(),
* createVmlShape({
* id: "picture",
* type: `#${PICTURE_FRAME_SHAPE_TYPE_ID}`,
* children: [createVmlImageData({ relationshipId: "rId1" })],
* }),
* ],
* });
* ```
*/
var createPictureFrameShapeType = () => createVmlShapeType({
id: PICTURE_FRAME_SHAPE_TYPE_ID,
coordinateSize: "21600,21600",
presetShapeType: PICTURE_FRAME_PRESET_SHAPE_TYPE,
preferRelative: true,
path: "m@4@5l@4@11@9@11@9@5xe",
filled: false,
stroked: false,
children: [
createVmlStroke({ joinStyle: "miter" }),
createVmlFormulas([
"if lineDrawn pixelLineWidth 0",
"sum @0 1 0",
"sum 0 0 @1",
"prod @2 1 2",
"prod @3 21600 pixelWidth",
"prod @3 21600 pixelHeight",
"sum @0 0 1",
"prod @6 1 2",
"prod @7 21600 pixelWidth",
"sum @8 21600 0",
"prod @7 21600 pixelHeight",
"sum @10 21600 0"
]),
createVmlPath({
extrusionOk: false,
gradientShapeOk: true,
connectType: "rect"
}),
createVmlLock({ aspectRatio: true })
]
});
//#endregion
//#region src/watermarks/vml/vml-image-data.ts
/**
* VML image data module for WordprocessingML documents.
*
* Image data attaches a picture to a VML shape and describes how it should be
* adjusted, for example washed out for use as a watermark.
*
* Reference: http://webapp.docx4java.org/OnlineDemo/ecma376/VML/imagedata.html
*
* @module
*/
/**
* Creates a VML image data element.
*
* The VML image data element (v:imagedata) references an embedded picture through
* a relationship and applies colour adjustments to it. Adjustment values are written
* in VML's fixed-point notation where 65536 represents 1.0.
*
* ## XSD Schema
* ```xml
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
* ```
*
* @param options - Configuration options for the image data
* @returns An XmlComponent representing the v:imagedata element
*
* @example
* ```typescript
* createVmlImageData({ relationshipId: "rId1", title: "logo", gain: 0.3, blackLevel: 0.35 });
* //
* ```
*/
var createVmlImageData = ({ relationshipId, title, gain, blackLevel, gamma, grayscale, biLevel, chromaKey } = {}) => new BuilderElement({
name: "v:imagedata",
attributes: {
relationshipId: {
key: "r:id",
value: relationshipId
},
title: {
key: "o:title",
value: title
},
gain: {
key: "gain",
value: gain === void 0 ? void 0 : vmlFixedPoint(gain)
},
blackLevel: {
key: "blacklevel",
value: blackLevel === void 0 ? void 0 : vmlFixedPoint(blackLevel)
},
gamma: {
key: "gamma",
value: gamma === void 0 ? void 0 : vmlFixedPoint(gamma)
},
grayscale: {
key: "grayscale",
value: vmlTrueFalse(grayscale)
},
biLevel: {
key: "bilevel",
value: vmlTrueFalse(biLevel)
},
chromaKey: {
key: "chromakey",
value: chromaKey
}
}
});
//#endregion
//#region \0@oxc-project+runtime@0.150.0/helpers/esm/typeof.js
function _typeof(o) {
"@babel/helpers - typeof";
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
return typeof o;
} : function(o) {
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
}, _typeof(o);
}
//#endregion
//#region \0@oxc-project+runtime@0.150.0/helpers/esm/toPrimitive.js
function toPrimitive(t, r) {
if ("object" != _typeof(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
//#endregion
//#region \0@oxc-project+runtime@0.150.0/helpers/esm/toPropertyKey.js
function toPropertyKey(t) {
var i = toPrimitive(t, "string");
return "symbol" == _typeof(i) ? i : i + "";
}
//#endregion
//#region \0@oxc-project+runtime@0.150.0/helpers/esm/defineProperty.js
function _defineProperty(e, r, t) {
return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
value: t,
enumerable: !0,
configurable: !0,
writable: !0
}) : e[r] = t, e;
}
//#endregion
//#region src/watermarks/image-watermark.ts
/**
* Image watermark module for WordprocessingML documents.
*
* An image watermark is a picture, typically a logo, drawn faintly behind the
* content of every page. Word implements it as a legacy picture shape placed in the
* page header, and this module produces the same markup.
*
* Reference: https://support.microsoft.com/en-us/office/insert-a-watermark-c0ec3d5a-6f3e-4f3c-a8b0-9d9a6f56d3fd
*
* @module
*/
/**
* Prefix Word gives to picture watermark shapes. Word's "Remove Watermark"
* command finds watermarks by this prefix.
*/
var IMAGE_WATERMARK_ID_PREFIX = "WordPictureWatermark";
/** Brightness multiplier Word applies for its "washout" effect. */
var WASHOUT_GAIN = .3;
/** Black level Word applies for its "washout" effect. */
var WASHOUT_BLACK_LEVEL = .35;
/** Number of English Metric Units in one pixel at 96 dpi. */
var EMUS_PER_PIXEL = 9525;
/** Number of points in one pixel at 96 dpi. */
var POINTS_PER_PIXEL = .75;
/**
* Converts a pixel measurement into points, rounded to two decimal places.
*
* @param pixels - The measurement in pixels
* @returns The measurement in points
*/
var pixelsToPoints = (pixels) => Math.round(pixels * POINTS_PER_PIXEL * 100) / 100;
/**
* Represents an image watermark in a WordprocessingML document.
*
* ImageWatermark is an inline element that belongs inside a paragraph, and the
* paragraph belongs in a header so that the watermark repeats on every page of
* the section. It renders as a picture shape centred on the page behind the
* document text, exactly as Word's Design > Watermark command does, so Word
* recognizes it and can remove or replace it through that command.
*
* The image is registered with the document's media collection during
* serialization and linked from the header through a relationship, in the same
* way as an ImageRun.
*
* @publicApi
*
* ## XSD Schema
* The watermark combines several elements:
* - w:r (run container)
* - w:pict (picture element containing VML)
* - v:shapetype (picture frame shape type definition)
* - v:shape (the positioned picture shape)
* - v:imagedata (the image reference and washout adjustments)
*
* @example
* ```typescript
* new Document({
* sections: [
* {
* headers: {
* default: new Header({
* children: [
* new Paragraph({
* children: [
* new ImageWatermark({
* type: "png",
* data: fs.readFileSync("./logo.png"),
* transformation: { width: 400, height: 400 },
* }),
* ],
* }),
* ],
* }),
* },
* children: [new Paragraph("Body text")],
* },
* ],
* });
* ```
*/
var ImageWatermark = class extends XmlComponent {
constructor({ type, data, transformation, washout = true, title }) {
super("w:r");
_defineProperty(this, "mediaData", void 0);
const fileName = `${hashedId(data)}.${type}`;
this.mediaData = {
type,
data: standardizeData(data),
fileName,
transformation: {
pixels: {
x: Math.round(transformation.width),
y: Math.round(transformation.height)
},
emus: {
x: Math.round(transformation.width * EMUS_PER_PIXEL),
y: Math.round(transformation.height * EMUS_PER_PIXEL)
}
}
};
this.root.push(createPict({ children: [createPictureFrameShapeType(), createVmlShape({
id: `${IMAGE_WATERMARK_ID_PREFIX}${uniqueId()}`,
type: `#${PICTURE_FRAME_SHAPE_TYPE_ID}`,
style: createWatermarkShapeStyle({
width: pixelsToPoints(transformation.width),
height: pixelsToPoints(transformation.height)
}),
allowInCell: false,
children: [createVmlImageData({
relationshipId: `rId{${fileName}}`,
title,
gain: washout ? WASHOUT_GAIN : void 0,
blackLevel: washout ? WASHOUT_BLACK_LEVEL : void 0
})]
})] }));
}
prepForXml(context) {
context.file.Media.addImage(this.mediaData.fileName, this.mediaData);
return super.prepForXml(context);
}
};
//#endregion
export { ImageWatermark, TextWatermark };