@vaadin-component-factory/vcf-pdf-viewer 0.9.0 → 0.9.4

package/src/core/xfa/connection_set.js

@@ -1,202 +0,0 @@
-/* Copyright 2021 Mozilla Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { $buildXFAObject, NamespaceIds } from "./namespaces.js";
-import { StringObject, XFAObject, XFAObjectArray } from "./xfa_object.js";
-
-const CONNECTION_SET_NS_ID = NamespaceIds.connectionSet.id;
-
-class ConnectionSet extends XFAObject {
-  constructor(attributes) {
-    super(CONNECTION_SET_NS_ID, "connectionSet", /* hasChildren = */ true);
-    this.wsdlConnection = new XFAObjectArray();
-    this.xmlConnection = new XFAObjectArray();
-    this.xsdConnection = new XFAObjectArray();
-  }
-}
-
-class EffectiveInputPolicy extends XFAObject {
-  constructor(attributes) {
-    super(CONNECTION_SET_NS_ID, "effectiveInputPolicy");
-    this.id = attributes.id || "";
-    this.name = attributes.name || "";
-    this.use = attributes.use || "";
-    this.usehref = attributes.usehref || "";
-  }
-}
-
-class EffectiveOutputPolicy extends XFAObject {
-  constructor(attributes) {
-    super(CONNECTION_SET_NS_ID, "effectiveOutputPolicy");
-    this.id = attributes.id || "";
-    this.name = attributes.name || "";
-    this.use = attributes.use || "";
-    this.usehref = attributes.usehref || "";
-  }
-}
-
-class Operation extends StringObject {
-  constructor(attributes) {
-    super(CONNECTION_SET_NS_ID, "operation");
-    this.id = attributes.id || "";
-    this.input = attributes.input || "";
-    this.name = attributes.name || "";
-    this.output = attributes.output || "";
-    this.use = attributes.use || "";
-    this.usehref = attributes.usehref || "";
-  }
-}
-
-class RootElement extends StringObject {
-  constructor(attributes) {
-    super(CONNECTION_SET_NS_ID, "rootElement");
-    this.id = attributes.id || "";
-    this.name = attributes.name || "";
-    this.use = attributes.use || "";
-    this.usehref = attributes.usehref || "";
-  }
-}
-
-class SoapAction extends StringObject {
-  constructor(attributes) {
-    super(CONNECTION_SET_NS_ID, "soapAction");
-    this.id = attributes.id || "";
-    this.name = attributes.name || "";
-    this.use = attributes.use || "";
-    this.usehref = attributes.usehref || "";
-  }
-}
-
-class SoapAddress extends StringObject {
-  constructor(attributes) {
-    super(CONNECTION_SET_NS_ID, "soapAddress");
-    this.id = attributes.id || "";
-    this.name = attributes.name || "";
-    this.use = attributes.use || "";
-    this.usehref = attributes.usehref || "";
-  }
-}
-
-class Uri extends StringObject {
-  constructor(attributes) {
-    super(CONNECTION_SET_NS_ID, "uri");
-    this.id = attributes.id || "";
-    this.name = attributes.name || "";
-    this.use = attributes.use || "";
-    this.usehref = attributes.usehref || "";
-  }
-}
-
-class WsdlAddress extends StringObject {
-  constructor(attributes) {
-    super(CONNECTION_SET_NS_ID, "wsdlAddress");
-    this.id = attributes.id || "";
-    this.name = attributes.name || "";
-    this.use = attributes.use || "";
-    this.usehref = attributes.usehref || "";
-  }
-}
-
-class WsdlConnection extends XFAObject {
-  constructor(attributes) {
-    super(CONNECTION_SET_NS_ID, "wsdlConnection", /* hasChildren = */ true);
-    this.dataDescription = attributes.dataDescription || "";
-    this.name = attributes.name || "";
-    this.effectiveInputPolicy = null;
-    this.effectiveOutputPolicy = null;
-    this.operation = null;
-    this.soapAction = null;
-    this.soapAddress = null;
-    this.wsdlAddress = null;
-  }
-}
-
-class XmlConnection extends XFAObject {
-  constructor(attributes) {
-    super(CONNECTION_SET_NS_ID, "xmlConnection", /* hasChildren = */ true);
-    this.dataDescription = attributes.dataDescription || "";
-    this.name = attributes.name || "";
-    this.uri = null;
-  }
-}
-
-class XsdConnection extends XFAObject {
-  constructor(attributes) {
-    super(CONNECTION_SET_NS_ID, "xsdConnection", /* hasChildren = */ true);
-    this.dataDescription = attributes.dataDescription || "";
-    this.name = attributes.name || "";
-    this.rootElement = null;
-    this.uri = null;
-  }
-}
-
-class ConnectionSetNamespace {
-  static [$buildXFAObject](name, attributes) {
-    if (ConnectionSetNamespace.hasOwnProperty(name)) {
-      return ConnectionSetNamespace[name](attributes);
-    }
-    return undefined;
-  }
-
-  static connectionSet(attrs) {
-    return new ConnectionSet(attrs);
-  }
-
-  static effectiveInputPolicy(attrs) {
-    return new EffectiveInputPolicy(attrs);
-  }
-
-  static effectiveOutputPolicy(attrs) {
-    return new EffectiveOutputPolicy(attrs);
-  }
-
-  static operation(attrs) {
-    return new Operation(attrs);
-  }
-
-  static rootElement(attrs) {
-    return new RootElement(attrs);
-  }
-
-  static soapAction(attrs) {
-    return new SoapAction(attrs);
-  }
-
-  static soapAddress(attrs) {
-    return new SoapAddress(attrs);
-  }
-
-  static uri(attrs) {
-    return new Uri(attrs);
-  }
-
-  static wsdlAddress(attrs) {
-    return new WsdlAddress(attrs);
-  }
-
-  static wsdlConnection(attrs) {
-    return new WsdlConnection(attrs);
-  }
-
-  static xmlConnection(attrs) {
-    return new XmlConnection(attrs);
-  }
-
-  static xsdConnection(attrs) {
-    return new XsdConnection(attrs);
-  }
-}
-
-export { ConnectionSetNamespace };

package/src/core/xfa/data.js

@@ -1,82 +0,0 @@
-/* Copyright 2021 Mozilla Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {
-  $getAttributes,
-  $getChildren,
-  $nodeName,
-  $setValue,
-  $toString,
-  $uid,
-} from "./xfa_object.js";
-
-class DataHandler {
-  constructor(root, data) {
-    this.data = data;
-    this.dataset = root.datasets || null;
-  }
-
-  serialize(storage) {
-    const stack = [[-1, this.data[$getChildren]()]];
-
-    while (stack.length > 0) {
-      const last = stack[stack.length - 1];
-      const [i, children] = last;
-      if (i + 1 === children.length) {
-        stack.pop();
-        continue;
-      }
-
-      const child = children[++last[0]];
-      const storageEntry = storage.get(child[$uid]);
-      if (storageEntry) {
-        child[$setValue](storageEntry);
-      } else {
-        const attributes = child[$getAttributes]();
-        for (const value of attributes.values()) {
-          const entry = storage.get(value[$uid]);
-          if (entry) {
-            value[$setValue](entry);
-            break;
-          }
-        }
-      }
-
-      const nodes = child[$getChildren]();
-      if (nodes.length > 0) {
-        stack.push([-1, nodes]);
-      }
-    }
-
-    const buf = [
-      `<xfa:datasets xmlns:xfa="http://www.xfa.org/schema/xfa-data/1.0/">`,
-    ];
-    if (this.dataset) {
-      // Dump nodes other than data: they can contains for example
-      // some data for choice lists.
-      for (const child of this.dataset[$getChildren]()) {
-        if (child[$nodeName] !== "data") {
-          child[$toString](buf);
-        }
-      }
-    }
-    this.data[$toString](buf);
-    buf.push("</xfa:datasets>");
-
-    return buf.join("");
-  }
-}
-
-export { DataHandler };

package/src/core/xfa/datasets.js

@@ -1,76 +0,0 @@
-/* Copyright 2021 Mozilla Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {
-  $appendChild,
-  $isNsAgnostic,
-  $namespaceId,
-  $nodeName,
-  $onChild,
-  XFAObject,
-  XmlObject,
-} from "./xfa_object.js";
-import { $buildXFAObject, NamespaceIds } from "./namespaces.js";
-
-const DATASETS_NS_ID = NamespaceIds.datasets.id;
-
-class Data extends XmlObject {
-  constructor(attributes) {
-    super(DATASETS_NS_ID, "data", attributes);
-  }
-
-  [$isNsAgnostic]() {
-    return true;
-  }
-}
-
-class Datasets extends XFAObject {
-  constructor(attributes) {
-    super(DATASETS_NS_ID, "datasets", /* hasChildren = */ true);
-    this.data = null;
-    this.Signature = null;
-  }
-
-  [$onChild](child) {
-    const name = child[$nodeName];
-    if (
-      (name === "data" && child[$namespaceId] === DATASETS_NS_ID) ||
-      (name === "Signature" &&
-        child[$namespaceId] === NamespaceIds.signature.id)
-    ) {
-      this[name] = child;
-    }
-    this[$appendChild](child);
-  }
-}
-
-class DatasetsNamespace {
-  static [$buildXFAObject](name, attributes) {
-    if (DatasetsNamespace.hasOwnProperty(name)) {
-      return DatasetsNamespace[name](attributes);
-    }
-    return undefined;
-  }
-
-  static datasets(attributes) {
-    return new Datasets(attributes);
-  }
-
-  static data(attributes) {
-    return new Data(attributes);
-  }
-}
-
-export { DatasetsNamespace };

package/src/core/xfa/factory.js

@@ -1,111 +0,0 @@
-/* Copyright 2021 Mozilla Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { $globalData, $toHTML } from "./xfa_object.js";
-import { Binder } from "./bind.js";
-import { DataHandler } from "./data.js";
-import { FontFinder } from "./fonts.js";
-import { stripQuotes } from "./utils.js";
-import { warn } from "../../shared/util.js";
-import { XFAParser } from "./parser.js";
-
-class XFAFactory {
-  constructor(data) {
-    try {
-      this.root = new XFAParser().parse(XFAFactory._createDocument(data));
-      const binder = new Binder(this.root);
-      this.form = binder.bind();
-      this.dataHandler = new DataHandler(this.root, binder.getData());
-      this.form[$globalData].template = this.form;
-    } catch (e) {
-      warn(`XFA - an error occurred during parsing and binding: ${e}`);
-    }
-  }
-
-  isValid() {
-    return this.root && this.form;
-  }
-
-  _createPages() {
-    try {
-      this.pages = this.form[$toHTML]();
-      this.dims = this.pages.children.map(c => {
-        const { width, height } = c.attributes.style;
-        return [0, 0, parseInt(width), parseInt(height)];
-      });
-    } catch (e) {
-      warn(`XFA - an error occurred during layout: ${e}`);
-    }
-  }
-
-  getBoundingBox(pageIndex) {
-    return this.dims[pageIndex];
-  }
-
-  get numberPages() {
-    if (!this.pages) {
-      this._createPages();
-    }
-    return this.dims.length;
-  }
-
-  setImages(images) {
-    this.form[$globalData].images = images;
-  }
-
-  setFonts(fonts) {
-    this.form[$globalData].fontFinder = new FontFinder(fonts);
-    const missingFonts = [];
-    for (let typeface of this.form[$globalData].usedTypefaces) {
-      typeface = stripQuotes(typeface);
-      const font = this.form[$globalData].fontFinder.find(typeface);
-      if (!font) {
-        missingFonts.push(typeface);
-      }
-    }
-
-    if (missingFonts.length > 0) {
-      return missingFonts;
-    }
-
-    return null;
-  }
-
-  appendFonts(fonts, reallyMissingFonts) {
-    this.form[$globalData].fontFinder.add(fonts, reallyMissingFonts);
-  }
-
-  getPages() {
-    if (!this.pages) {
-      this._createPages();
-    }
-    const pages = this.pages;
-    this.pages = null;
-    return pages;
-  }
-
-  serializeData(storage) {
-    return this.dataHandler.serialize(storage);
-  }
-
-  static _createDocument(data) {
-    if (!data["/xdp:xdp"]) {
-      return data["xdp:xdp"];
-    }
-    return Object.values(data).join("");
-  }
-}
-
-export { XFAFactory };

package/src/core/xfa/fonts.js

@@ -1,181 +0,0 @@
-/* Copyright 2021 Mozilla Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { warn } from "../../shared/util.js";
-
-class FontFinder {
-  constructor(pdfFonts) {
-    this.fonts = new Map();
-    this.cache = new Map();
-    this.warned = new Set();
-    this.defaultFont = null;
-    this.add(pdfFonts);
-  }
-
-  add(pdfFonts, reallyMissingFonts = null) {
-    for (const pdfFont of pdfFonts) {
-      this.addPdfFont(pdfFont);
-    }
-    for (const pdfFont of this.fonts.values()) {
-      if (!pdfFont.regular) {
-        pdfFont.regular = pdfFont.italic || pdfFont.bold || pdfFont.bolditalic;
-      }
-    }
-
-    if (!reallyMissingFonts || reallyMissingFonts.size === 0) {
-      return;
-    }
-    const myriad = this.fonts.get("PdfJS-Fallback-PdfJS-XFA");
-    for (const missing of reallyMissingFonts) {
-      this.fonts.set(missing, myriad);
-    }
-  }
-
-  addPdfFont(pdfFont) {
-    const cssFontInfo = pdfFont.cssFontInfo;
-    const name = cssFontInfo.fontFamily;
-    let font = this.fonts.get(name);
-    if (!font) {
-      font = Object.create(null);
-      this.fonts.set(name, font);
-      if (!this.defaultFont) {
-        this.defaultFont = font;
-      }
-    }
-    let property = "";
-    const fontWeight = parseFloat(cssFontInfo.fontWeight);
-    if (parseFloat(cssFontInfo.italicAngle) !== 0) {
-      property = fontWeight >= 700 ? "bolditalic" : "italic";
-    } else if (fontWeight >= 700) {
-      property = "bold";
-    }
-
-    if (!property) {
-      if (
-        pdfFont.name.includes("Bold") ||
-        (pdfFont.psName && pdfFont.psName.includes("Bold"))
-      ) {
-        property = "bold";
-      }
-      if (
-        pdfFont.name.includes("Italic") ||
-        pdfFont.name.endsWith("It") ||
-        (pdfFont.psName &&
-          (pdfFont.psName.includes("Italic") || pdfFont.psName.endsWith("It")))
-      ) {
-        property += "italic";
-      }
-    }
-
-    if (!property) {
-      property = "regular";
-    }
-
-    font[property] = pdfFont;
-  }
-
-  getDefault() {
-    return this.defaultFont;
-  }
-
-  find(fontName, mustWarn = true) {
-    let font = this.fonts.get(fontName) || this.cache.get(fontName);
-    if (font) {
-      return font;
-    }
-
-    const pattern = /,|-|_| |bolditalic|bold|italic|regular|it/gi;
-    let name = fontName.replace(pattern, "");
-    font = this.fonts.get(name);
-    if (font) {
-      this.cache.set(fontName, font);
-      return font;
-    }
-    name = name.toLowerCase();
-
-    const maybe = [];
-    for (const [family, pdfFont] of this.fonts.entries()) {
-      if (family.replace(pattern, "").toLowerCase().startsWith(name)) {
-        maybe.push(pdfFont);
-      }
-    }
-
-    if (maybe.length === 0) {
-      for (const [, pdfFont] of this.fonts.entries()) {
-        if (
-          pdfFont.regular.name &&
-          pdfFont.regular.name
-            .replace(pattern, "")
-            .toLowerCase()
-            .startsWith(name)
-        ) {
-          maybe.push(pdfFont);
-        }
-      }
-    }
-
-    if (maybe.length === 0) {
-      name = name.replace(/psmt|mt/gi, "");
-      for (const [family, pdfFont] of this.fonts.entries()) {
-        if (family.replace(pattern, "").toLowerCase().startsWith(name)) {
-          maybe.push(pdfFont);
-        }
-      }
-    }
-
-    if (maybe.length === 0) {
-      for (const pdfFont of this.fonts.values()) {
-        if (
-          pdfFont.regular.name &&
-          pdfFont.regular.name
-            .replace(pattern, "")
-            .toLowerCase()
-            .startsWith(name)
-        ) {
-          maybe.push(pdfFont);
-        }
-      }
-    }
-
-    if (maybe.length >= 1) {
-      if (maybe.length !== 1 && mustWarn) {
-        warn(`XFA - Too many choices to guess the correct font: ${fontName}`);
-      }
-      this.cache.set(fontName, maybe[0]);
-      return maybe[0];
-    }
-
-    if (mustWarn && !this.warned.has(fontName)) {
-      this.warned.add(fontName);
-      warn(`XFA - Cannot find the font: ${fontName}`);
-    }
-    return null;
-  }
-}
-
-function selectFont(xfaFont, typeface) {
-  if (xfaFont.posture === "italic") {
-    if (xfaFont.weight === "bold") {
-      return typeface.bolditalic;
-    }
-    return typeface.italic;
-  } else if (xfaFont.weight === "bold") {
-    return typeface.bold;
-  }
-
-  return typeface.regular;
-}
-
-export { FontFinder, selectFont };