drjones/hydro-builder-app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial project import

Browse Source
This commit is contained in:
drjones
2026-06-13 17:36:44 -07:00
commit ad2a18cc8d
18471 changed files with 4497570 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
node_modules/jspdf-autotable/LICENSE.txt generated vendored Normal file
View File

@@ -0,0 +1,22 @@
The MIT License (MIT)
Copyright (c) 2014 Simon Bengtsson, https://github.com/simonbengtsson/jspdf-autotable
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

272
node_modules/jspdf-autotable/README.md generated vendored Normal file
View File

@@ -0,0 +1,272 @@
# jsPDF-AutoTable - Table plugin for jsPDF
**Generate PDF tables with Javascript**
This jsPDF plugin adds the ability to generate PDF tables either by parsing HTML tables or by using Javascript data directly. Check out the [demo](https://simonbengtsson.github.io/jsPDF-AutoTable/) or [examples](https://github.com/simonbengtsson/jsPDF-AutoTable/tree/master/examples).
![sample javascript table pdf](samples.png)
## Installation
Get jsPDF and this plugin by doing one of these things:
- `npm install jspdf jspdf-autotable`
- Download [jspdf](https://raw.githubusercontent.com/MrRio/jsPDF/master/dist/jspdf.umd.min.js) and [jspdf-autotable](https://raw.githubusercontent.com/simonbengtsson/jsPDF-AutoTable/master/dist/jspdf.plugin.autotable.js) from github
- Use a CDN, for example: [https://unpkg.com/jspdf](https://unpkg.com/jspdf) and [https://unpkg.com/jspdf-autotable](https://unpkg.com/jspdf-autotable)
## Usage
```js
import { jsPDF } from 'jspdf'
import { autoTable } from 'jspdf-autotable'
const doc = new jsPDF()
// It can parse html:
// <table id="my-table"><!-- ... --></table>
autoTable(doc, { html: '#my-table' })
// Or use javascript directly:
autoTable(doc, {
head: [['Name', 'Email', 'Country']],
body: [
['David', 'david@example.com', 'Sweden'],
['Castille', 'castille@example.com', 'Spain'],
// ...
],
})
doc.save('table.pdf')
```
You can also use the plugin methods directly on the jsPDF documents:
```js
import { jsPDF } from 'jspdf'
import { applyPlugin } from 'jspdf-autotable'
applyPlugin(jsPDF)
const doc = new jsPDF()
doc.autoTable({ html: '#my-table' })
doc.save('table.pdf')
```
The third usage option is with downloaded or CDN dist files
```html
<script src="jspdf.min.js"></script>
<script src="jspdf.plugin.autotable.min.js"></script>
<script>
const doc = new jsPDF()
doc.autoTable({ html: '#my-table' })
doc.save('table.pdf')
</script>
```
Checkout more examples in [examples.js](examples) which is also the source code for the [demo](https://simonbengtsson.github.io/jsPDF-AutoTable/) documents.
## Options
Below is a list of all options supported in the plugin. All of them are used in the [examples](examples).
#### Content options
The only thing required is either the html or body option. If you want more control over the columns you can specify the columns property. If columns are not set they will be automatically computed based on the content of the html content or head, body and foot.
- `html: string|HTMLTableElement` A css selector (for example "#table") or an html table element.
- `head: CellDef[][]` For example [['ID', 'Name', 'Country']]
- `body: CellDef[][]` For example [['1', 'Simon', 'Sweden'], ['2', 'Karl', 'Norway']]
- `foot: CellDef[][]` For example [['ID', 'Name', 'Country']]
- `columns: ColumnDef[]` For example [{header: 'ID', dataKey: 'id'}, {header: 'Name', dataKey: 'name'}]. Only use this option if you want more control over the columns. If not specified the columns will be automatically generated based on the content in html or head/body/foot
- `includeHiddenHtml: boolean = false` If hidden html with `display: none` should be included or not when the content comes from an html table
`CellDef: string|{content: string, rowSpan: number, colSpan: number, styles: StyleDef}`
Note that cell styles can also be set dynamically with hooks.
`ColumnDef: string|{header?: string, dataKey: string}`
The header property is optional and the values of any content in `head` will be used if not set. Normally it's easier to use the html or head/body/foot style of initiating a table, but columns can be useful if your body content comes directly from an api or if you would like to specify a dataKey on each column to make it more readable to style specific columns in the hooks or columnStyles.
Usage with colspan, rowspan and inline cell styles:
```js
autoTable(doc, {
body: [
[{ content: 'Text', colSpan: 2, rowSpan: 2, styles: { halign: 'center' } }],
],
})
```
#### Styling options
- `theme: 'striped'|'grid'|'plain' = 'striped'`
- `styles: StyleDef`
- `headStyles: StyleDef`
- `bodyStyles: StyleDef`
- `footStyles: StyleDef`
- `alternateRowStyles: StyleDef`
- `columnStyles: {&columnDataKey: StyleDef}` Note that the columnDataKey is normally the index of the column, but could also be the `dataKey` of a column if content initialized with the columns property
`StyleDef`:
- `font: 'helvetica'|'times'|'courier' = 'helvetica'`
- `fontStyle: 'normal'|'bold'|'italic'|'bolditalic' = 'normal'`
- `overflow: 'linebreak'|'ellipsize'|'visible'|'hidden' = 'linebreak'`
- `fillColor: Color? = null`
- `textColor: Color? = 20`
- `cellWidth: 'auto'|'wrap'|number = 'auto'`
- `minCellWidth: number? = 10`
- `minCellHeight: number = 0`
- `halign: 'left'|'center'|'right' = 'left'`
- `valign: 'top'|'middle'|'bottom' = 'top'`
- `fontSize: number = 10`
- `cellPadding: Padding = 10`
- `lineColor: Color = 10`
- `lineWidth: border = 0` // If 0, no border is drawn
`Color`:
Either false for transparent, hex string, gray level 0-255 or rbg array e.g. [255, 0, 0]
false|string|number|[number, number, number]
`Padding`:
Either a number or object `{top: number, right: number, bottom: number, left: number}`
`border`:
Either a number or object `{top: number, right: number, bottom: number, left: number}`
Styles work similar to css and can be overridden by more specific styles. Overriding order:
1. Theme styles
2. `styles`
3. `headStyles`, `bodyStyles` and `footStyles`
4. `alternateRowStyles`
5. `columnStyles`
Styles for specific cells can also be applied using either the hooks (see hooks section above) or the `styles` property on the cell definition object (see content section above).
Example usage of column styles (note that the 0 in the columnStyles below should be dataKey if columns option used)
```js
// Example usage with columnStyles,
autoTable(doc, {
styles: { fillColor: [255, 0, 0] },
columnStyles: { 0: { halign: 'center', fillColor: [0, 255, 0] } }, // Cells in first column centered and green
margin: { top: 10 },
body: [
['Sweden', 'Japan', 'Canada'],
['Norway', 'China', 'USA'],
['Denmark', 'China', 'Mexico'],
],
})
// Example usage of columns property. Note that America will not be included even though it exist in the body since there is no column specified for it.
autoTable(doc, {
columnStyles: { europe: { halign: 'center' } }, // European countries centered
body: [
{ europe: 'Sweden', america: 'Canada', asia: 'China' },
{ europe: 'Norway', america: 'Mexico', asia: 'Japan' },
],
columns: [
{ header: 'Europe', dataKey: 'europe' },
{ header: 'Asia', dataKey: 'asia' },
],
})
```
#### Other options
- `useCss: boolean = false`
- `startY: number = null` Where the table should start to be printed (basically a margin top value only for the first page)
- `margin: Margin = 40`
- `pageBreak: 'auto'|'avoid'|'always'` If set to `avoid` the plugin will only split a table onto multiple pages if table height is larger than page height.
- `rowPageBreak: 'auto'|'avoid' = 'auto'` If set to `avoid` the plugin will only split a row onto multiple pages if row height is larger than page height.
- `tableWidth: 'auto'|'wrap'|number = 'auto'`
- `showHead: 'everyPage'|'firstPage'|'never' = 'everyPage''`
- `showFoot: 'everyPage'|'lastPage'|'never' = 'everyPage''`
- `tableLineWidth: number = 0`
- `tableLineColor: Color = 200` The table line/border color
- `horizontalPageBreak: boolean = false` To split/break the table into multiple pages if the given table width exceeds the page width
- `horizontalPageBreakRepeat: string|number|string[]|number[]` To repeat the given column in the split pages, works when `horizontalPageBreak = true`. The accepted values are column dataKeys, such as `'id'`, `recordId` or column indexes, such as `0`, `1` or array for multiple columns.
- `horizontalPageBreakBehaviour: 'immediately'|'afterAllRows' = 'afterAllRows'` How the horizontal page breaks behave, works when `horizontalPageBreak = true`
`Margin`:
Either a number or object `{top: number, right: number, bottom: number, left: number}`
### Hooks
You can customize the content and styling of the table by using the hooks. See the custom styles example for usage of the hooks.
- `didParseCell: (HookData) => {}` - Called when the plugin finished parsing cell content. Can be used to override content or styles for a specific cell.
- `willDrawCell: (HookData) => {}` - Called before a cell or row is drawn. Can be used to call native jspdf styling functions such as `doc.setTextColor` or change position of text etc before it is drawn.
- `didDrawCell: (HookData) => {}` - Called after a cell has been added to the page. Can be used to draw additional cell content such as images with `doc.addImage`, additional text with `doc.addText` or other jspdf shapes.
- `willDrawPage: (HookData) => {}` - Called before starting to draw on a page. Can be used to add headers or any other content that you want on each page there is an autotable.
- `didDrawPage: (HookData) => {}` - Called after the plugin has finished drawing everything on a page. Can be used to add footers with page numbers or any other content that you want on each page there is an autotable.
All hooks functions get passed an HookData object with information about the state of the table and cell. For example the position on the page, which page it is on etc.
`HookData`:
- `table: Table`
- `pageNumber: number` The page number specific to this table
- `settings: object` Parsed user supplied options
- `doc` The jsPDF document instance of this table
- `cursor: { x: number, y: number }` To draw each table this plugin keeps a cursor state where the next cell/row should be drawn. You can assign new values to this cursor to dynamically change how the cells and rows are drawn.
For cell hooks these properties are also passed:
- `cell: Cell`
- `row: Row`
- `column: Column`
- `section: 'head'|'body'|'foot'`
To see what is included in the `Table`, `Row`, `Column` and `Cell` types, either log them to the console or take a look at `src/models.ts`
```js
// Example with an image drawn in each cell in the first column
autoTable(doc, {
didDrawCell: (data) => {
if (data.section === 'body' && data.column.index === 0) {
const base64Img = 'data:image/jpeg;base64,iVBORw0KGgoAAAANS...'
doc.addImage(base64Img, 'JPEG', data.cell.x + 2, data.cell.y + 2, 10, 10)
}
},
})
```
## API
- `doc.autoTable({ /* options */ })`
- `autoTable(doc, { /* options */ })`
- `jsPDF.autoTableSetDefaults({ /* ... */ })` Use for setting global defaults which will be applied for all tables
- `applyPlugin(jsPDF)` Use for adding the autoTable api to any jsPDF instance
If you want to know something about the last table that was drawn you can use `doc.lastAutoTable`. It has a `doc.lastAutoTable.finalY` property among other things that has the value of the last printed y coordinate on a page. This can be used to draw text, multiple tables or other content after a table.
## Contributions
Contributions are always welcome, especially on open issues. If you have something major you want to add or change, please post an issue about it first to discuss it further. Describe the change you are making and ideally link to related issues. If the pull request is a bug fix it is helpful with examples of what did not work before but works now etc.
The workflow for contributing would be something like this:
- Start watcher with `npm start`
- Make code changes
- Make sure all examples works
- Commit and submit pull request
Don't include updated build files in the pull request since these are auto created during release.
**If you don't use [Prettier](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode) on autosave, please run `yarn run format-all` before opening your PR**
### Release workflow
- Run Release workflow on github (or run `npm version <semver>` and npm run deploy)
- Verify release at https://simonbengtsson.github.io/jsPDF-AutoTable
### Pull requests locally
- `PR=472 npm run checkout-pr`
### Release prerelease
- `npm version prerelease`
- `git push && git push --tags && npm publish --tag alpha`

326
node_modules/jspdf-autotable/dist/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,326 @@
// Generated by dts-bundle-generator v9.5.1
export type MarginPadding = {
top: number;
right: number;
bottom: number;
left: number;
};
export declare class HookData {
table: Table;
pageNumber: number;
settings: Settings;
doc: jsPDFDocument;
cursor: Pos | null;
constructor(doc: DocHandler, table: Table, cursor: Pos | null);
}
export declare class CellHookData extends HookData {
cell: Cell;
row: Row;
column: Column;
section: "head" | "body" | "foot";
constructor(doc: DocHandler, table: Table, cell: Cell, row: Row, column: Column, cursor: Pos | null);
}
export interface ContentInput {
body: RowInput[];
head: RowInput[];
foot: RowInput[];
columns: ColumnInput[];
}
export interface TableInput {
id: string | number | undefined;
settings: Settings;
styles: StylesProps;
hooks: HookProps;
content: ContentInput;
}
export type Pos = {
x: number;
y: number;
};
export type PageHook = (data: HookData) => void | boolean;
export type CellHook = (data: CellHookData) => void | boolean;
export interface HookProps {
didParseCell: CellHook[];
willDrawCell: CellHook[];
didDrawCell: CellHook[];
willDrawPage: PageHook[];
didDrawPage: PageHook[];
}
export interface Settings {
includeHiddenHtml: boolean;
useCss: boolean;
theme: "striped" | "grid" | "plain";
startY: number;
margin: MarginPadding;
pageBreak: "auto" | "avoid" | "always";
rowPageBreak: "auto" | "avoid";
tableWidth: "auto" | "wrap" | number;
showHead: "everyPage" | "firstPage" | "never";
showFoot: "everyPage" | "lastPage" | "never";
tableLineWidth: number;
tableLineColor: Color;
horizontalPageBreak?: boolean;
horizontalPageBreakBehaviour?: "immediately" | "afterAllRows";
horizontalPageBreakRepeat?: string | number | string[] | number[] | null;
}
export interface StylesProps {
styles: Partial<Styles>;
headStyles: Partial<Styles>;
bodyStyles: Partial<Styles>;
footStyles: Partial<Styles>;
alternateRowStyles: Partial<Styles>;
columnStyles: {
[key: string]: Partial<Styles>;
};
}
export type ContentSettings = {
body: Row[];
head: Row[];
foot: Row[];
columns: Column[];
};
export declare class Table {
readonly id?: string | number;
readonly settings: Settings;
readonly styles: StylesProps;
readonly hooks: HookProps;
readonly columns: Column[];
readonly head: Row[];
readonly body: Row[];
readonly foot: Row[];
pageNumber: number;
finalY?: number;
startPageNumber?: number;
constructor(input: TableInput, content: ContentSettings);
getHeadHeight(columns: Column[]): number;
getFootHeight(columns: Column[]): number;
allRows(): Row[];
callCellHooks(doc: DocHandler, handlers: CellHook[], cell: Cell, row: Row, column: Column, cursor: {
x: number;
y: number;
} | null): boolean;
callEndPageHooks(doc: DocHandler, cursor: {
x: number;
y: number;
}): void;
callWillDrawPageHooks(doc: DocHandler, cursor: {
x: number;
y: number;
}): void;
getWidth(pageWidth: number): number;
}
export declare class Row {
readonly raw: HTMLTableRowElement | RowInput;
readonly element?: HTMLTableRowElement;
readonly index: number;
readonly section: Section;
readonly cells: {
[key: string]: Cell;
};
spansMultiplePages: boolean;
height: number;
constructor(raw: RowInput | HTMLTableRowElement, index: number, section: Section, cells: {
[key: string]: Cell;
}, spansMultiplePages?: boolean);
getMaxCellHeight(columns: Column[]): number;
hasRowSpan(columns: Column[]): boolean;
canEntireRowFit(height: number, columns: Column[]): boolean;
getMinimumRowHeight(columns: Column[], doc: DocHandler): number;
}
export type Section = "head" | "body" | "foot";
export declare class Cell {
raw: HTMLTableCellElement | CellInput;
styles: Styles;
text: string[];
section: Section;
colSpan: number;
rowSpan: number;
contentHeight: number;
contentWidth: number;
wrappedWidth: number;
minReadableWidth: number;
minWidth: number;
width: number;
height: number;
x: number;
y: number;
constructor(raw: CellInput, styles: Styles, section: Section);
getTextPos(): Pos;
getContentHeight(scaleFactor: number, lineHeightFactor?: number): number;
padding(name: "vertical" | "horizontal" | "top" | "bottom" | "left" | "right"): number;
}
export declare class Column {
raw: ColumnInput | null;
dataKey: string | number;
index: number;
wrappedWidth: number;
minReadableWidth: number;
minWidth: number;
width: number;
constructor(dataKey: string | number, raw: ColumnInput | null, index: number);
getMaxCustomCellWidth(table: Table): number;
}
export interface LineWidths {
bottom: number;
top: number;
left: number;
right: number;
}
export type FontStyle = "normal" | "bold" | "italic" | "bolditalic";
export type StandardFontType = "helvetica" | "times" | "courier";
export type CustomFontType = string;
export type FontType = StandardFontType | CustomFontType;
export type HAlignType = "left" | "center" | "right" | "justify";
export type VAlignType = "top" | "middle" | "bottom";
export type OverflowType = "linebreak" | "ellipsize" | "visible" | "hidden" | ((text: string | string[], width: number) => string | string[]);
export type CellWidthType = "auto" | "wrap" | number;
export interface Styles {
font: FontType;
fontStyle: FontStyle;
overflow: OverflowType;
fillColor: Color;
textColor: Color;
halign: HAlignType;
valign: VAlignType;
fontSize: number;
cellPadding: MarginPaddingInput;
lineColor: Color;
lineWidth: number | Partial<LineWidths>;
cellWidth: CellWidthType;
minCellHeight: number;
minCellWidth: number;
}
export type ThemeType = "striped" | "grid" | "plain" | null;
export type PageBreakType = "auto" | "avoid" | "always";
export type RowPageBreakType = "auto" | "avoid";
export type TableWidthType = "auto" | "wrap" | number;
export type ShowHeadType = "everyPage" | "firstPage" | "never" | boolean;
export type ShowFootType = "everyPage" | "lastPage" | "never" | boolean;
export type HorizontalPageBreakBehaviourType = "immediately" | "afterAllRows";
export interface UserOptions {
includeHiddenHtml?: boolean;
useCss?: boolean;
theme?: ThemeType;
startY?: number | false;
margin?: MarginPaddingInput;
pageBreak?: PageBreakType;
rowPageBreak?: RowPageBreakType;
tableWidth?: TableWidthType;
showHead?: ShowHeadType;
showFoot?: ShowFootType;
tableLineWidth?: number;
tableLineColor?: Color;
tableId?: string | number;
head?: RowInput[];
body?: RowInput[];
foot?: RowInput[];
html?: string | HTMLTableElement;
columns?: ColumnInput[];
horizontalPageBreak?: boolean;
horizontalPageBreakRepeat?: string[] | number[] | string | number;
horizontalPageBreakBehaviour?: HorizontalPageBreakBehaviourType;
styles?: Partial<Styles>;
bodyStyles?: Partial<Styles>;
headStyles?: Partial<Styles>;
footStyles?: Partial<Styles>;
alternateRowStyles?: Partial<Styles>;
columnStyles?: {
[key: string]: Partial<Styles>;
};
/** Called when the plugin finished parsing cell content. Can be used to override content or styles for a specific cell. */
didParseCell?: CellHook;
/** Called before a cell or row is drawn. Can be used to call native jspdf styling functions such as `doc.setTextColor` or change position of text etc before it is drawn. */
willDrawCell?: CellHook;
/** Called after a cell has been added to the page. Can be used to draw additional cell content such as images with `doc.addImage`, additional text with `doc.addText` or other jspdf shapes. */
didDrawCell?: CellHook;
/** Called before starting to draw on a page. Can be used to add headers or any other content that you want on each page there is an autotable. */
willDrawPage?: PageHook;
/** Called after the plugin has finished drawing everything on a page. Can be used to add footers with page numbers or any other content that you want on each page there is an autotable. */
didDrawPage?: PageHook;
}
export type ColumnInput = string | number | {
header?: CellInput;
footer?: CellInput;
dataKey?: string | number;
};
export type Color = [
number,
number,
number
] | number | string | false;
export type MarginPaddingInput = number | number[] | {
top?: number;
right?: number;
bottom?: number;
left?: number;
horizontal?: number;
vertical?: number;
};
export interface CellDef {
rowSpan?: number;
colSpan?: number;
styles?: Partial<Styles>;
content?: string | string[] | number;
_element?: HTMLTableCellElement;
}
declare class HtmlRowInput extends Array<CellDef> {
_element: HTMLTableRowElement;
constructor(element: HTMLTableRowElement);
}
export type CellInput = null | string | string[] | number | boolean | CellDef;
export type RowInput = {
[key: string]: CellInput;
} | HtmlRowInput | CellInput[];
export type jsPDFConstructor = any;
export type jsPDFDocument = any;
export type Opts = {
[key: string]: string | number;
};
declare class DocHandler {
private readonly jsPDFDocument;
readonly userStyles: Partial<Styles>;
constructor(jsPDFDocument: jsPDFDocument);
static setDefaults(defaults: UserOptions, doc?: jsPDFDocument | null): void;
private static unifyColor;
applyStyles(styles: Partial<Styles>, fontOnly?: boolean): void;
splitTextToSize(text: string | string[], size: number, opts: Opts): string[];
/**
* Adds a rectangle to the PDF
* @param x Coordinate (in units declared at inception of PDF document) against left edge of the page
* @param y Coordinate (in units declared at inception of PDF document) against upper edge of the page
* @param width Width (in units declared at inception of PDF document)
* @param height Height (in units declared at inception of PDF document)
* @param fillStyle A string specifying the painting style or null. Valid styles include: 'S' [default] - stroke, 'F' - fill, and 'DF' (or 'FD') - fill then stroke.
*/
rect(x: number, y: number, width: number, height: number, fillStyle: "S" | "F" | "DF" | "FD"): any;
getLastAutoTable(): Table | null;
getTextWidth(text: string | string[]): number;
getDocument(): any;
setPage(page: number): void;
addPage(): any;
getFontList(): {
[key: string]: string[] | undefined;
};
getGlobalOptions(): UserOptions;
getDocumentOptions(): UserOptions;
pageSize(): {
width: number;
height: number;
};
scaleFactor(): number;
getLineHeightFactor(): number;
getLineHeight(fontSize: number): number;
pageNumber(): number;
}
export declare function applyPlugin(jsPDF: jsPDFConstructor): void;
export type autoTableInstanceType = (options: UserOptions) => void;
export declare function autoTable(d: jsPDFDocument, options: UserOptions): void;
export declare function __createTable(d: jsPDFDocument, options: UserOptions): Table;
export declare function __drawTable(d: jsPDFDocument, table: Table): void;
export {
autoTable as default,
};
export {};

2222
node_modules/jspdf-autotable/dist/jspdf.plugin.autotable.js generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

10
node_modules/jspdf-autotable/dist/jspdf.plugin.autotable.min.js generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

2086
node_modules/jspdf-autotable/dist/jspdf.plugin.autotable.mjs generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

88
node_modules/jspdf-autotable/package.json generated vendored Normal file
View File

@@ -0,0 +1,88 @@
{
"name": "jspdf-autotable",
"version": "5.0.8",
"description": "Generate pdf tables with javascript (jsPDF plugin)",
"main": "dist/jspdf.plugin.autotable.js",
"exports": {
".": {
"types": "./dist/index.d.ts",
"require": "./dist/jspdf.plugin.autotable.js",
"import": "./dist/jspdf.plugin.autotable.mjs"
},
"./es": {
"types": "./dist/index.d.ts",
"default": "./dist/jspdf.plugin.autotable.mjs"
}
},
"types": "dist/index",
"files": [
"dist/*"
],
"browserslist": [
"last 2 versions",
"> 1%",
"IE 11"
],
"directories": {
"example": "examples"
},
"peerDependencies": {
"jspdf": "^2 || ^3 || ^4"
},
"prettier": {
"semi": false,
"singleQuote": true
},
"devDependencies": {
"@eslint/eslintrc": "^3.3.5",
"@eslint/js": "^10.0.1",
"@rollup/plugin-typescript": "^12.3.0",
"@typescript-eslint/eslint-plugin": "^8.59.3",
"@typescript-eslint/parser": "^8.59.3",
"dts-bundle-generator": "^9.5.1",
"eslint": "^10.4.0",
"eslint-config-prettier": "^10.1.8",
"eslint-plugin-prettier": "^5.5.5",
"happy-dom": "^20.9.0",
"jspdf": "^4.2.1",
"npm-check-updates": "^22.2.0",
"prettier": "^3.8.3",
"rollup": "^4.60.4",
"ts-loader": "^9.5.7",
"tslib": "^2.8.1",
"typescript": "^6.0.3",
"vitest": "^4.1.6",
"webpack": "^5.106.2",
"webpack-cli": "^7.0.2",
"webpack-dev-server": "^5.2.4"
},
"scripts": {
"start": "webpack serve --config webpack.config.mjs --mode=development",
"checkout-pr": "git fetch origin pull/$PR/head:pr$PR && git checkout pr$PR",
"start-external": "webpack serve --config webpack.config.mjs --mode=development --host 0.0.0.0",
"build": "webpack --mode=production && webpack --mode=production --env minified && npm run buildes && npm run types",
"buildes": "rollup --config rollup.config.mjs",
"lint": "eslint --ext=.ts .",
"test": "vitest run",
"format": "prettier --write src",
"version": "npm test && npm run build && git add -A dist",
"hosting": "git push origin main:gh-pages -f",
"deploy": "git push --follow-tags && npm run hosting && npm publish",
"types": "dts-bundle-generator src/main.ts -o ./dist/index.d.ts"
},
"repository": {
"type": "git",
"url": "https://github.com/simonbengtsson/jsPDF-AutoTable.git"
},
"keywords": [
"pdf",
"table",
"jspdf"
],
"author": "Simon Bengtsson <dev@simonbengtsson.com>",
"license": "MIT",
"bugs": {
"url": "https://github.com/simonbengtsson/jsPDF-AutoTable/issues"
},
"homepage": "https://simonbengtsson.github.io/jsPDF-AutoTable"
}