@progress/kendo-vue-pdf 3.5.0-dev.202208020811 → 3.5.1-dev.202208110751

package/dist/esm/grid/GridPDFExport.d.ts

@@ -0,0 +1,37 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { PDFExportProps } from '../PDFExportProps';
+export interface GridPDFExportProps extends PDFExportProps {
+}
+/**
+ * @hidden
+ */
+export interface GridPDFExportMethods extends Vue2type {
+    save: (data?: any[], callback?: () => void) => void;
+    getSavePDF: () => any;
+}
+/**
+ * @hidden
+ */
+export interface GridPDFExportState {
+    saveGridPDF: any;
+    gridComponent: any;
+    v3: boolean;
+}
+/**
+ * @hidden
+ */
+export interface GridPDFExportAll extends GridPDFExportMethods, GridPDFExportState {
+}
+/**
+ * @hidden
+ */
+declare let GridPdfExportVue2: ComponentOptions<Vue2type, DefaultData<{}>, DefaultMethods<GridPDFExportAll>, {}, RecordPropsDefinition<GridPDFExportProps>>;
+/**
+ * @hidden
+ */
+declare const GridPdfExport: DefineComponent<GridPDFExportProps, any, {}, {}, GridPDFExportMethods, {}, {}, {}, string, GridPDFExportProps, GridPDFExportProps, {}>;
+export { GridPdfExport, GridPdfExportVue2 };

package/dist/esm/grid/GridPDFExport.js

@@ -0,0 +1,78 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+import { savePDF } from '../savePDF.js';
+import { provideSaveGridPDF } from './provideSaveGridPDF.js';
+import { getDefaultSlots } from '@progress/kendo-vue-common';
+/**
+ * @hidden
+ */
+
+var GridPdfExportVue2 = {
+  name: 'grid-pdf-export',
+  props: {
+    author: String,
+    avoidLinks: [Boolean, String],
+    forcePageBreak: String,
+    keepTogether: String,
+    creator: String,
+    date: Date,
+    imageResolution: Number,
+    fileName: String,
+    forceProxy: Boolean,
+    keywords: String,
+    landscape: Boolean,
+    margin: [String, Object],
+    pageTemplate: [Object, Function],
+    paperSize: [String, Object],
+    repeatHeaders: Boolean,
+    scale: Number,
+    proxyData: Object,
+    proxyURL: String,
+    proxyTarget: String,
+    producer: String,
+    subject: String,
+    title: String
+  },
+  created: function created() {
+    this.saveGridPDF = provideSaveGridPDF(this.getSavePDF());
+  },
+  methods: {
+    save: function save(data, callback) {
+      var defaultSlot = getDefaultSlots(this); // @ts-ignore
+
+      var gridSlot = defaultSlot.filter(function (child) {
+        return child && child.tag && child.tag.toLowerCase().indexOf('grid') !== -1 || child.componentOptions && child.componentOptions.tag && child.componentOptions.tag.toLowerCase().indexOf('grid') !== -1 || child.type && child.type.name && child.type.name.toLowerCase().indexOf('grid') !== -1;
+      });
+
+      if (gridSlot.length) {
+        this.gridComponent = this.v3 ? gridSlot[0] : gridSlot[0].componentInstance;
+        this.saveGridPDF(this.gridComponent, this.$props, callback, data, this.v3);
+      }
+    },
+    getSavePDF: function getSavePDF() {
+      return savePDF;
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+    var defaultSlot = getDefaultSlots(this);
+    return h("div", [defaultSlot]);
+  }
+};
+/**
+ * @hidden
+ */
+
+var GridPdfExport = GridPdfExportVue2;
+export { GridPdfExport, GridPdfExportVue2 };

package/dist/esm/grid/dom-queries.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @hidden
+ */
+export declare const hasClasses: (element: HTMLElement, classNames: string) => boolean;
+/**
+ * @hidden
+ */
+export declare const matchesClasses: (classNames: string) => (element: HTMLElement) => boolean;
+/**
+ * @hidden
+ */
+export declare const matchesNodeName: (nodeName: string) => any;
+/**
+ * @hidden
+ */
+export declare const closest: (node: any, predicate: any) => any;
+/**
+ * @hidden
+ */
+export declare const closestInScope: (node: any, predicate: any, scope: any) => any;
+/**
+ * @hidden
+ */
+export declare const contains: (parent: any, node: any, matchSelf?: boolean) => boolean;
+/**
+ * @hidden
+ */
+export declare const isVisible: (element: any) => boolean;
+/**
+ * @hidden
+ */
+export declare const isFocusable: (element: any, checkVisibility?: boolean) => boolean;
+/**
+ * @hidden
+ */
+export declare const findElement: (node: any, predicate: (element: any) => boolean, matchSelf?: boolean) => any;
+/**
+ * @hidden
+ */
+export declare const findFocusable: (element: any, checkVisibility?: boolean) => any;
+/**
+ * @hidden
+ */
+export declare const findFocusableChild: (element: any, checkVisibility?: boolean) => any;

package/dist/esm/grid/dom-queries.js

@@ -0,0 +1,123 @@
+var focusableRegex = /^(?:a|input|select|option|textarea|button|object)$/i;
+var NODE_NAME_PREDICATES = {};
+var toClassList = function (classNames) { return String(classNames).trim().split(' '); };
+/**
+ * @hidden
+ */
+export var hasClasses = function (element, classNames) {
+    var namesList = toClassList(classNames);
+    return Boolean(toClassList(element.className).find(function (className) { return namesList.indexOf(className) >= 0; }));
+};
+/**
+ * @hidden
+ */
+export var matchesClasses = function (classNames) {
+    return function (element) { return hasClasses(element, classNames); };
+};
+/**
+ * @hidden
+ */
+export var matchesNodeName = function (nodeName) {
+    if (!NODE_NAME_PREDICATES[nodeName]) {
+        NODE_NAME_PREDICATES[nodeName] = function (element) {
+            return String(element.nodeName).toLowerCase() === nodeName.toLowerCase();
+        };
+    }
+    return NODE_NAME_PREDICATES[nodeName];
+};
+/**
+ * @hidden
+ */
+export var closest = function (node, predicate) {
+    while (node && !predicate(node)) {
+        node = node.parentNode;
+    }
+    return node;
+};
+/**
+ * @hidden
+ */
+export var closestInScope = function (node, predicate, scope) {
+    while (node && node !== scope && !predicate(node)) {
+        node = node.parentNode;
+    }
+    if (node !== scope) {
+        return node;
+    }
+};
+/**
+ * @hidden
+ */
+export var contains = function (parent, node, matchSelf) {
+    if (matchSelf === void 0) { matchSelf = false; }
+    var outside = !closest(node, function (child) { return child === parent; });
+    if (outside) {
+        return false;
+    }
+    var el = closest(node, function (child) { return child === node; });
+    return el && (matchSelf || el !== parent);
+};
+/**
+ * @hidden
+ */
+export var isVisible = function (element) {
+    var rect = element.getBoundingClientRect();
+    var hasSize = rect.width > 0 && rect.height > 0;
+    var hasPosition = rect.x !== 0 && rect.y !== 0;
+    // Elements can have zero size due to styling, but they should still count as visible.
+    // For example, the selection checkbox has no size, but is made visible through styling.
+    return (hasSize || hasPosition) && window.getComputedStyle(element).visibility !== 'hidden';
+};
+/**
+ * @hidden
+ */
+export var isFocusable = function (element, checkVisibility) {
+    if (checkVisibility === void 0) { checkVisibility = true; }
+    if (element.tagName) {
+        var tagName = element.tagName.toLowerCase();
+        var tabIndex = element.getAttribute('tabIndex');
+        var skipTab = tabIndex === '-1';
+        var focusable = tabIndex !== null && !skipTab;
+        if (focusableRegex.test(tagName)) {
+            focusable = !element.disabled && !skipTab;
+        }
+        return focusable && (!checkVisibility || isVisible(element));
+    }
+    return false;
+};
+/**
+ * @hidden
+ */
+export var findElement = function (node, predicate, matchSelf) {
+    if (matchSelf === void 0) { matchSelf = true; }
+    if (!node) {
+        return;
+    }
+    if (matchSelf && predicate(node)) {
+        return node;
+    }
+    node = node.firstChild;
+    while (node) {
+        if (node.nodeType === 1) {
+            var element = findElement(node, predicate);
+            if (element) {
+                return element;
+            }
+        }
+        node = node.nextSibling;
+    }
+};
+/**
+ * @hidden
+ */
+export var findFocusable = function (element, checkVisibility) {
+    if (checkVisibility === void 0) { checkVisibility = true; }
+    return findElement(element, function (node) { return isFocusable(node, checkVisibility); });
+};
+/**
+ * @hidden
+ */
+export var findFocusableChild = function (element, checkVisibility) {
+    if (checkVisibility === void 0) { checkVisibility = true; }
+    return findElement(element, function (node) { return isFocusable(node, checkVisibility); }, false);
+};

package/dist/esm/grid/export-element.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @hidden
+ */
+export declare const exportElement: (wrapper: HTMLElement) => HTMLElement;

package/dist/esm/grid/export-element.js

@@ -0,0 +1,78 @@
+import { GridQuery, HEADER_CLASS, FOOTER_CLASS } from './grid-query.js';
+var FIRST_CLASS = 'k-first';
+var appendNodes = function (element, nodes) {
+    var length = nodes.length;
+    for (var idx = 0; idx < length; idx++) {
+        element.appendChild(nodes[idx].cloneNode(true));
+    }
+};
+var wrapTable = function (table) {
+    var wrapper = document.createElement('div');
+    wrapper.className = 'k-widget k-grid';
+    wrapper.appendChild(table);
+    return wrapper;
+};
+var createTableElement = function (sources) {
+    var sourceCount = sources.length;
+    var element = sources[0].cloneNode(true);
+    var rowsCount = element.rows.length;
+    if (sourceCount > 1) {
+        for (var rowIdx = 0; rowIdx < rowsCount; rowIdx++) {
+            for (var sourceIdx = 1; sourceIdx < sourceCount; sourceIdx++) {
+                appendNodes(element.rows[rowIdx], sources[sourceIdx].rows[rowIdx].cells);
+            }
+        }
+    }
+    return element;
+};
+var setFirstCellClass = function (header, headers) {
+    if (headers.length > 1 && header.rows.length > 1) {
+        for (var idx = 1; idx < header.rows.length; idx++) {
+            var firstCellIndex = headers[0].rows[idx].cells.length;
+            var cell = header.rows[idx].cells[firstCellIndex];
+            if (String(cell.className).indexOf(FIRST_CLASS) === -1) {
+                cell.className += " ".concat(FIRST_CLASS);
+            }
+        }
+    }
+};
+var createTable = function (colGroups, headers, bodies, footers) {
+    var table = document.createElement('table');
+    var colGroup = colGroups[0].cloneNode(true);
+    for (var idx = 1; idx < colGroups.length; idx++) {
+        appendNodes(colGroup, colGroups[idx].querySelectorAll('col'));
+    }
+    var header = createTableElement(headers);
+    var body = createTableElement(bodies);
+    header.className = HEADER_CLASS;
+    setFirstCellClass(header, headers);
+    table.appendChild(colGroup);
+    table.appendChild(header);
+    table.appendChild(body);
+    if (footers.length) {
+        var footer = createTableElement(footers);
+        footer.className = FOOTER_CLASS;
+        table.appendChild(footer);
+    }
+    return wrapTable(table);
+};
+/**
+ * @hidden
+ */
+export var exportElement = function (wrapper) {
+    var query = new GridQuery(wrapper);
+    var content = query.content();
+    var result;
+    if (content) {
+        var colGroups = [content.querySelector('colgroup')];
+        var headers = [query.header().querySelector('thead')];
+        var bodies = [content.querySelector('tbody')];
+        var footer = query.footer();
+        var footers = footer ? [footer.querySelector('tfoot')] : [];
+        result = createTable(colGroups, headers, bodies, footers);
+    }
+    else {
+        result = wrapTable(query.table().cloneNode(true));
+    }
+    return result;
+};

package/dist/esm/grid/grid-query.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @hidden
+ */
+export declare const HEADER_CLASS: string;
+/**
+ * @hidden
+ */
+export declare const FOOTER_CLASS: string;
+/**
+ * @hidden
+ */
+export declare class GridQuery {
+    private element;
+    private headerWrap;
+    private list;
+    private footerWrap;
+    constructor(element: HTMLElement);
+    content(locked?: boolean): Element;
+    header(locked?: boolean): Element;
+    footer(locked?: boolean): Element;
+    table(): Node;
+}

package/dist/esm/grid/grid-query.js

@@ -0,0 +1,37 @@
+import { matchesClasses, matchesNodeName, findElement } from './dom-queries.js';
+/**
+ * @hidden
+ */
+export var HEADER_CLASS = 'k-grid-header';
+/**
+ * @hidden
+ */
+export var FOOTER_CLASS = 'k-grid-footer';
+var TABLE = 'TABLE';
+var matchesTable = matchesNodeName(TABLE);
+var suffix = function (locked) { return locked ? 'locked' : 'wrap'; };
+/**
+ * @hidden
+ */
+var GridQuery = /** @class */ (function () {
+    function GridQuery(element) {
+        this.element = element;
+        this.list = findElement(element, matchesClasses("k-grid-container"));
+    }
+    GridQuery.prototype.content = function (locked) {
+        return findElement(this.list, matchesClasses("k-grid-content".concat(locked ? '-locked' : '')));
+    };
+    GridQuery.prototype.header = function (locked) {
+        this.headerWrap = this.headerWrap || findElement(this.element, matchesClasses(HEADER_CLASS));
+        return findElement(this.headerWrap, matchesClasses("".concat(HEADER_CLASS, "-").concat(suffix(locked))));
+    };
+    GridQuery.prototype.footer = function (locked) {
+        this.footerWrap = this.footerWrap || findElement(this.element, matchesClasses(FOOTER_CLASS));
+        return findElement(this.footerWrap, matchesClasses("".concat(FOOTER_CLASS, "-").concat(suffix(locked))));
+    };
+    GridQuery.prototype.table = function () {
+        return findElement(this.element, matchesTable);
+    };
+    return GridQuery;
+}());
+export { GridQuery };

package/dist/esm/grid/provideSaveGridPDF.d.ts

@@ -0,0 +1,5 @@
+import { PDFExportProps } from '../PDFExportProps';
+/**
+ * @hidden
+ */
+export declare function provideSaveGridPDF(savePDF: (domElement: HTMLElement, options?: PDFExportProps, callback?: () => void) => void): (grid: any, pdfExportOptions?: PDFExportProps, callback?: () => void, data?: any, columns?: any) => void;

package/dist/esm/grid/provideSaveGridPDF.js

@@ -0,0 +1,134 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+}; // @ts-ignore
+
+
+import * as Vue from 'vue';
+import { canUseDOM } from '@progress/kendo-vue-common';
+var allVue = Vue;
+var h = allVue.h;
+var createApp = allVue.createApp;
+import { exportElement } from './export-element.js';
+/**
+ * @hidden
+ */
+
+export function provideSaveGridPDF(savePDF) {
+  return function (grid, pdfExportOptions, callback, data, columns) {
+    if (pdfExportOptions === void 0) {
+      pdfExportOptions = {};
+    }
+
+    return saveGridPDF(savePDF, grid, pdfExportOptions, callback, data, columns);
+  };
+}
+
+function saveGridPDF(savePDF, grid, pdfExportOptions, callback, data, v3) {
+  if (pdfExportOptions === void 0) {
+    pdfExportOptions = {};
+  }
+
+  renderGrid();
+  var gridOuterWrapper;
+  var gridInnerWrapper;
+  var finalContainer;
+  var gridInstance;
+
+  function renderGrid() {
+    if (!canUseDOM) {
+      return;
+    }
+
+    gridOuterWrapper = document.createElement('div');
+    gridOuterWrapper.setAttribute('style', 'position:absolute; left: -5000px; top: 0px;');
+    gridInnerWrapper = document.createElement('div');
+    gridOuterWrapper.appendChild(gridInnerWrapper);
+    document.body.appendChild(gridOuterWrapper);
+    var customDataProps = data && {
+      dataItems: data,
+      total: data.length,
+      pageSize: data.length,
+      skip: 0
+    };
+
+    if (v3) {
+      var gridForPdf = {
+        render: function render() {
+          return h(grid.type, __assign(__assign({}, grid.props), customDataProps), grid.children);
+        },
+        store: grid.$store,
+        mounted: function mounted() {
+          // @ts-ignore
+          if (this.$el.style) {
+            // @ts-ignore
+            this.$el.style.width = '1000px';
+          }
+
+          onGridRendered.call(this);
+        }
+      };
+      gridInstance = createApp(gridForPdf);
+      gridInstance.mount(gridInnerWrapper);
+    } else {
+      var gridConstructor = Object.getPrototypeOf(grid).constructor;
+      gridInstance = new gridConstructor({
+        propsData: Object.assign({}, grid.$props, customDataProps),
+        store: grid.$store,
+        mounted: function mounted() {
+          if (gridInstance.$el.style) {
+            gridInstance.$el.style.width = '1000px';
+          }
+
+          onGridRendered.call(gridInstance);
+        }
+      });
+      gridInstance.$slots = grid.$slots;
+      gridInstance.$scopedSlots = grid.$scopedSlots;
+      gridInstance.$mount(gridInnerWrapper);
+    }
+  }
+
+  function onGridRendered() {
+    savePDF(prepareFinalElementForExport.call(this), pdfExportOptions, cleanUpAndInvokeCallback);
+  }
+
+  function cleanUpAndInvokeCallback() {
+    if (gridInstance.unmount) {
+      gridInstance.unmount();
+    } else {
+      gridInstance.$destroy();
+    }
+
+    document.body.removeChild(gridOuterWrapper);
+    document.body.removeChild(finalContainer);
+    gridOuterWrapper = finalContainer = undefined;
+
+    if (callback) {
+      callback();
+    }
+  }
+
+  function prepareFinalElementForExport() {
+    /* Ultimatelly, there is no need for double DOM-copying of the grid.
+    The one in this method is a copied Angular implementation
+    that has been plugged almost seemlessly. */
+    finalContainer = document.createElement('div');
+    finalContainer.className = 'k-grid-pdf-export-element';
+    var result = exportElement(this.$el);
+    finalContainer.appendChild(result);
+    document.body.appendChild(finalContainer);
+    return result;
+  }
+}

package/dist/esm/main.d.ts

@@ -0,0 +1,6 @@
+import { PDFExport, PDFExportVue2 } from './PDFExport';
+import { PDFExportProps } from './PDFExportProps';
+import { PageTemplateProps } from './PageTemplateProps';
+import { savePDF } from './savePDF';
+import { GridPdfExport, GridPdfExportVue2, GridPDFExportProps } from './grid/GridPDFExport';
+export { PDFExport, PDFExportVue2, PDFExportProps, PageTemplateProps, savePDF, GridPdfExport, GridPdfExportVue2, GridPDFExportProps };

package/dist/esm/main.js

@@ -0,0 +1,11 @@
+import { PDFExport, PDFExportVue2 } from './PDFExport.js';
+// import { PDFMargin, PDFMarginProps } from './PDFMargin.js';
+import { savePDF } from './savePDF.js';
+import { GridPdfExport, GridPdfExportVue2 } from './grid/GridPDFExport.js';
+export { PDFExport, PDFExportVue2, savePDF, GridPdfExport, GridPdfExportVue2 };
+// Automatic installation if Vue has been added to the global scope.
+var vue = 'Vue';
+if (typeof window !== 'undefined' && window[vue] && window[vue].component) {
+    window[vue].component('kendo-pdf-export', PDFExport);
+    window[vue].component('kendo-grid-pdf-export', GridPdfExport);
+}

package/dist/esm/package-metadata.d.ts

@@ -0,0 +1,5 @@
+import { PackageMetadata } from '@progress/kendo-licensing';
+/**
+ * @hidden
+ */
+export declare const packageMetadata: PackageMetadata;

package/dist/esm/package-metadata.js

@@ -0,0 +1,11 @@
+/**
+ * @hidden
+ */
+export var packageMetadata = {
+    name: '@progress/kendo-vue-pdf',
+    productName: 'Kendo UI for Vue',
+    productCodes: ['KENDOUIVUE', 'KENDOUICOMPLETE'],
+    publishDate: 1660203609,
+    version: '',
+    licensingDocsUrl: 'https://www.telerik.com/kendo-vue-ui/my-license/?utm_medium=product&utm_source=kendovue&utm_campaign=kendo-ui-vue-purchase-license-keys-warning'
+};

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+                    "type": "module"
+                 }

package/dist/esm/savePDF.d.ts

@@ -0,0 +1,9 @@
+import { PDFExportProps } from './PDFExportProps';
+/**
+ * Saves the content of a DOM element to a PDF file.
+ *
+ * @param domElement - The root DOM element to save to a PDF file.
+ * @param options - The export options.
+ * @param callback - The callback to be executed after the PDF is saved.
+ */
+export declare function savePDF(domElement: HTMLElement, options?: PDFExportProps, callback?: () => void): void;

package/dist/esm/savePDF.js

@@ -0,0 +1,14 @@
+import { drawDOM, exportPDF } from '@progress/kendo-drawing';
+import { saveAs } from '@progress/kendo-file-saver';
+import KendoDrawingAdapter from './KendoDrawingAdapter.js';
+/**
+ * Saves the content of a DOM element to a PDF file.
+ *
+ * @param domElement - The root DOM element to save to a PDF file.
+ * @param options - The export options.
+ * @param callback - The callback to be executed after the PDF is saved.
+ */
+export function savePDF(domElement, options, callback) {
+    if (options === void 0) { options = {}; }
+    new KendoDrawingAdapter(drawDOM, exportPDF, saveAs, domElement, options).savePDF(callback);
+}

package/dist/npm/KendoDrawingAdapter.js

@@ -13,8 +13,8 @@ var defaultCreator = 'Kendo UI PDF Generator';
  */
 var KendoDrawingAdapter = /** @class */ (function () {
     function KendoDrawingAdapter(drawDOM, exportPDF, saveAs, domElement, options) {
-        var _this = this;
         if (options === void 0) { options = {}; }
+        var _this = this;
         this.drawDOM = drawDOM;
         this.exportPDF = exportPDF;
         this.saveAs = saveAs;

package/dist/npm/PDFExport.js

@@ -65,12 +65,12 @@ var PDFExportVue2 = {
     };
   },
   created: function created() {
-    kendo_vue_common_1.validatePackage(package_metadata_1.packageMetadata);
+    (0, kendo_vue_common_1.validatePackage)(package_metadata_1.packageMetadata);
   },
   // @ts-ignore
   render: function render(createElement) {
     var h = gh || createElement;
-    var defaultSlot = kendo_vue_common_1.getDefaultSlots(this);
+    var defaultSlot = (0, kendo_vue_common_1.getDefaultSlots)(this);
     return h("div", [defaultSlot]);
   } // To do: we should consider whether we need a margin-top, margin-left, etc. props
   // private getOptions() {