@chalabi/svelte-sheets 2.0.0

package/dist/Sheet.svelte.d.ts

@@ -0,0 +1,42 @@
+import type { Config } from "./defaultconfig.js";
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const Sheet: $$__sveltets_2_IsomorphicComponent<{
+    [x: string]: any;
+    data?: (string | number | boolean)[][];
+    columns?: any[];
+    rows?: any[];
+    mergeCells?: Record<string, number[]>;
+    style?: {
+        [cellIndex: string]: string;
+    };
+    selected?: [string, string];
+    extended?: [string, string];
+    currentValue?: string | number | boolean;
+    clipboard: [string, string];
+    options: Config;
+    className?: string;
+    theme?: "light" | "dark" | string;
+    startY?: number;
+    startX?: number;
+    endY?: number;
+    endX?: number;
+    onInputChange?: (value: any, row: any, column: any) => void;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {
+    onInputChange: (value: any, row: any, column: any) => void;
+}, string>;
+type Sheet = InstanceType<typeof Sheet>;
+export default Sheet;

package/dist/Toolbar.svelte

@@ -0,0 +1,69 @@
+<script lang="ts">import XLSX from "xlsx";
+import { convert } from "./convert.js";
+export let sheetNames;
+export let sheets = [];
+export let active = 0;
+// declare all possible table object
+let fileinput;
+let files;
+$: files && files[0] && reader && reader.readAsArrayBuffer(files[0]);
+let reader;
+if (FileReader != undefined) {
+    reader = new FileReader();
+    reader.onload = () => {
+        sheets = [];
+        active = 0;
+        const wb = XLSX.read(new Uint8Array(reader.result), {
+            type: "array",
+            cellFormula: true,
+            cellStyles: true,
+        });
+        sheets = convert(wb);
+        sheetNames = sheets.map((s) => s.sheetName);
+    };
+}
+</script>
+
+<input
+  type="file"
+  class="hidden"
+  name="file"
+  bind:this={fileinput}
+  bind:files
+/>
+
+<div class="flex">
+  <button on:click={(_) => fileinput.click()}>Open XLSX file</button>
+  {#each sheetNames as sn, i}
+    <div
+      on:click={(_) => {
+        active = i;
+      }}
+      class={"ml-4 cursor-pointer " + (i == active ? "active" : "")}
+    >
+      {sn}
+    </div>
+  {/each}
+</div>
+
+<style>
+  .hidden {
+    height: 0;
+    width: 0;
+    opacity: 0;
+  }
+  .active {
+    border-bottom: 1px solid teal;
+  }
+  .flex {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+  }
+  .ml-4 {
+    margin-left: 1rem;
+  }
+  .cursor-pointer {
+    cursor: pointer;
+  }
+</style>

package/dist/Toolbar.svelte.d.ts

@@ -0,0 +1,22 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const Toolbar: $$__sveltets_2_IsomorphicComponent<{
+    sheetNames: any;
+    sheets?: any[];
+    active?: number;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type Toolbar = InstanceType<typeof Toolbar>;
+export default Toolbar;

package/dist/actions/copypaste.d.ts

@@ -0,0 +1 @@
+export declare function copypaste(node: any): void;

package/dist/actions/copypaste.js

@@ -0,0 +1,24 @@
+// copy-paste action (also support cut)
+export function copypaste(node) {
+    const keyPressed = {};
+    function onKeyDown(e) {
+        keyPressed[e.keyCode] = true;
+        if (keyPressed[91] && keyPressed[88]) {
+            e.preventDefault();
+            node.dispatchEvent(new CustomEvent("cut"));
+        }
+        if (keyPressed[91] && keyPressed[88]) {
+            e.preventDefault();
+            node.dispatchEvent(new CustomEvent("paste"));
+        }
+        if (keyPressed[91] && keyPressed[88]) {
+            e.preventDefault();
+            node.dispatchEvent(new CustomEvent("copy"));
+        }
+    }
+    function onKeyUp(e) {
+        keyPressed[e.keyCode] = false;
+    }
+    node.addEventListener("keydown", onKeyDown);
+    node.addEventListener("keyup", onKeyUp);
+}

package/dist/actions/draggable.d.ts

@@ -0,0 +1,3 @@
+export declare function draggable(node: any): {
+    destroy(): void;
+};

package/dist/actions/draggable.js

@@ -0,0 +1,37 @@
+export function draggable(node) {
+    let x;
+    let y;
+    function handleMousedown(event) {
+        x = event.clientX;
+        y = event.clientY;
+        node.dispatchEvent(new CustomEvent("dragging", {
+            detail: { x: 0, y: 0 },
+        }));
+        window.addEventListener("mousemove", handleMousemove);
+        window.addEventListener("mouseup", handleMouseup);
+    }
+    function handleMousemove(event) {
+        const dx = event.clientX - x;
+        const dy = event.clientY - y;
+        // x = event.clientX;
+        // y = event.clientY;
+        node.dispatchEvent(new CustomEvent("dragging", {
+            detail: { x: dx, y: dy },
+        }));
+    }
+    function handleMouseup(event) {
+        const dx = event.clientX - x;
+        const dy = event.clientY - y;
+        node.dispatchEvent(new CustomEvent("dragging", {
+            detail: { x: dx, y: dy },
+        }));
+        window.removeEventListener("mousemove", handleMousemove);
+        window.removeEventListener("mouseup", handleMouseup);
+    }
+    node.addEventListener("mousedown", handleMousedown);
+    return {
+        destroy() {
+            node.removeEventListener("mousedown", handleMousedown);
+        },
+    };
+}

package/dist/actions/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./copypaste.js";
+export * from "./draggable.js";
+export * from "./resizable.js";
+export * from "./rightclick.js";
+export * from "./selected.js";

package/dist/actions/index.js

@@ -0,0 +1,5 @@
+export * from "./copypaste.js";
+export * from "./draggable.js";
+export * from "./resizable.js";
+export * from "./rightclick.js";
+export * from "./selected.js";

package/dist/actions/resizable.d.ts

@@ -0,0 +1,3 @@
+export declare function resizable(node: any): {
+    destroy(): void;
+};

package/dist/actions/resizable.js

@@ -0,0 +1,37 @@
+export function resizable(node) {
+    let x;
+    let y;
+    function handleMousedown(event) {
+        x = event.clientX;
+        y = event.clientY;
+        node.dispatchEvent(new CustomEvent("resizing", {
+            detail: { x: 0, y: 0 },
+        }));
+        window.addEventListener("mousemove", handleMousemove);
+        window.addEventListener("mouseup", handleMouseup);
+    }
+    function handleMousemove(event) {
+        const dx = event.clientX - x;
+        const dy = event.clientY - y;
+        x = event.clientX;
+        y = event.clientY;
+        node.dispatchEvent(new CustomEvent("resizing", {
+            detail: { x: dx, y: dy },
+        }));
+    }
+    function handleMouseup(event) {
+        const dx = event.clientX - x;
+        const dy = event.clientY - y;
+        node.dispatchEvent(new CustomEvent("resizing", {
+            detail: { x: dx, y: dy },
+        }));
+        window.removeEventListener("mousemove", handleMousemove);
+        window.removeEventListener("mouseup", handleMouseup);
+    }
+    node.addEventListener("mousedown", handleMousedown);
+    return {
+        destroy() {
+            node.removeEventListener("mousedown", handleMousedown);
+        },
+    };
+}

package/dist/actions/rightclick.d.ts

@@ -0,0 +1 @@
+export declare function rightclick(node: any): void;

package/dist/actions/rightclick.js

@@ -0,0 +1 @@
+export function rightclick(node) { }

package/dist/actions/selected.d.ts

@@ -0,0 +1,5 @@
+export declare function selection(node: any, { selection, rows, columns }: {
+    selection: any;
+    rows: any;
+    columns: any;
+}): void;

package/dist/actions/selected.js

@@ -0,0 +1,10 @@
+import XLSX from "xlsx";
+export function selection(node, { selection, rows, columns }) {
+    const viewport = node.getBoundingClientRect();
+    const topleft = XLSX.utils.decode_cell(selection[0]);
+    const bottomRight = XLSX.utils.decode_cell(selection[1]);
+    const top = node.getElementByClassName(".top");
+    const bottom = node.getElementByClassName(".bottom");
+    const left = node.getElementByClassName(".left");
+    const right = node.getElementByClassName(".right");
+}

package/dist/convert.d.ts

@@ -0,0 +1,16 @@
+export declare function getColumnName(i: any): string;
+/**
+ * Convert jexcel id to excel like column name
+ *
+ * @param string id
+ * @return string id
+ */
+export declare function getColumnNameFromId(cellId: any): string;
+/**
+ * Convert excel like column to jexcel id
+ *
+ * @param string id
+ * @return string id
+ */
+export declare function getIdFromColumnName(id: any, arr: any): any;
+export declare function convert(workbook: any): any[];

package/dist/convert.js

@@ -0,0 +1,164 @@
+export function getColumnName(i) {
+    var letter = "";
+    if (i > 701) {
+        letter += String.fromCharCode(64 + parseInt(i / 676));
+        letter += String.fromCharCode(64 + parseInt((i % 676) / 26));
+    }
+    else if (i > 25) {
+        letter += String.fromCharCode(64 + parseInt(i / 26));
+    }
+    letter += String.fromCharCode(65 + (i % 26));
+    return letter;
+}
+/**
+ * Convert jexcel id to excel like column name
+ *
+ * @param string id
+ * @return string id
+ */
+export function getColumnNameFromId(cellId) {
+    if (!Array.isArray(cellId)) {
+        cellId = cellId.split("-");
+    }
+    return getColumnName(parseInt(cellId[0])) + (parseInt(cellId[1]) + 1);
+}
+/**
+ * Convert excel like column to jexcel id
+ *
+ * @param string id
+ * @return string id
+ */
+export function getIdFromColumnName(id, arr) {
+    // Get the letters
+    var t = /^[a-zA-Z]+/.exec(id);
+    if (t) {
+        // Base 26 calculation
+        var code = 0;
+        for (var i = 0; i < t[0].length; i++) {
+            code +=
+                parseInt(t[0].charCodeAt(i) - 64) * Math.pow(26, t[0].length - 1 - i);
+        }
+        code--;
+        // Make sure jexcel starts on zero
+        if (code < 0) {
+            code = 0;
+        }
+        // Number
+        var number = parseInt(/[0-9]+$/.exec(id));
+        if (number > 0) {
+            number--;
+        }
+        if (arr == true) {
+            id = [code, number];
+        }
+        else {
+            id = code + "-" + number;
+        }
+    }
+    return id;
+}
+export function convert(workbook) {
+    var spreadsheets = [];
+    workbook.SheetNames.forEach(function (sheetName) {
+        var spreadsheet = {
+            rows: [],
+            columns: [],
+            data: [],
+            style: {},
+            sheetName: sheetName,
+            mergeCells: [],
+        };
+        // Column widths
+        var temp = workbook.Sheets[sheetName]["!cols"];
+        if (temp && temp.length) {
+            for (var i = 0; i < temp.length; i++) {
+                spreadsheet.columns[i] = {};
+                if (temp[i] && temp[i].wpx) {
+                    spreadsheet.columns[i].width = temp[i].wpx + "px";
+                }
+            }
+        }
+        // Rows heights
+        var temp = workbook.Sheets[sheetName]["!rows"];
+        if (temp && temp.length) {
+            for (var i = 0; i < temp.length; i++) {
+                if (temp[i] && temp[i].hpx) {
+                    spreadsheet.rows[i] = {};
+                    spreadsheet.rows[i].height = temp[i].hpx + "px";
+                }
+            }
+        }
+        // Merge cells
+        var temp = workbook.Sheets[sheetName]["!merges"];
+        if (temp && temp.length > 0) {
+            for (var i = 0; i < temp.length; i++) {
+                var x1 = temp[i].s.c;
+                var y1 = temp[i].s.r;
+                var x2 = temp[i].e.c;
+                var y2 = temp[i].e.r;
+                var key = getColumnNameFromId([x1, y1]);
+                spreadsheet.mergeCells[key] = [x2 - x1 + 1, y2 - y1 + 1];
+            }
+        }
+        // Data container
+        var max_x = 0;
+        var max_y = 0;
+        var temp = Object.keys(workbook.Sheets[sheetName]);
+        for (var i = 0; i < temp.length; i++) {
+            if (temp[i].substr(0, 1) != "!") {
+                var cell = workbook.Sheets[sheetName][temp[i]];
+                var info = getIdFromColumnName(temp[i], true);
+                if (!spreadsheet.data[info[1]]) {
+                    spreadsheet.data[info[1]] = [];
+                }
+                spreadsheet.data[info[1]][info[0]] = cell.f ? "=" + cell.f : cell.w;
+                if (max_x < info[0]) {
+                    max_x = info[0];
+                }
+                if (max_y < info[1]) {
+                    max_y = info[1];
+                }
+                // Style
+                if (cell.style && Object.keys(cell.style).length > 0) {
+                    spreadsheet.style[temp[i]] = cell.style;
+                }
+                if (cell.s && cell.s.fgColor) {
+                    if (spreadsheet.style[temp[i]]) {
+                        spreadsheet.style[temp[i]] += ";";
+                    }
+                    // console.log(
+                    //   "style bg-color ",
+                    //   spreadsheet.style[temp[i]],
+                    //   cell.s.fgColor.rgb
+                    // );
+                    spreadsheet.style[temp[i]] =
+                        (spreadsheet.style[temp[i]] || "") +
+                            "background-color:#" +
+                            cell.s.fgColor.rgb;
+                }
+            }
+        }
+        // ensure we have enough columns to display all the data
+        const maxColumns = spreadsheet.data.reduce((acc, cur) => (cur.length > acc ? (acc = cur.length) : acc), 0);
+        spreadsheet.columns = spreadsheet.columns.slice(0, maxColumns);
+        for (var i = 0; i <= maxColumns; i++) {
+            if (!spreadsheet.columns[i]) {
+                spreadsheet.columns[i] = { width: "100px" };
+            }
+        }
+        for (var j = 0; j <= max_y; j++) {
+            for (var i = 0; i <= max_x; i++) {
+                if (!spreadsheet.data[j]) {
+                    spreadsheet.data[j] = [];
+                }
+                if (!spreadsheet.data[j][i]) {
+                    if (maxColumns < i) {
+                        spreadsheet.data[j][i] = "";
+                    }
+                }
+            }
+        }
+        spreadsheets.push(spreadsheet);
+    });
+    return spreadsheets;
+}

package/dist/defaultconfig.d.ts

@@ -0,0 +1,138 @@
+export declare const defaultconfig: {
+    url: any;
+    copyCompatibility: boolean;
+    root: any;
+    colHeaders: any[];
+    colWidths: any[];
+    colAlignments: any[];
+    nestedHeaders: any;
+    defaultColWidth: number;
+    defaultColAlign: string;
+    minSpareRows: number;
+    minSpareCols: number;
+    minDimensions: number[];
+    allowExport: boolean;
+    includeHeadersOnDownload: boolean;
+    includeHeadersOnCopy: boolean;
+    columnSorting: boolean;
+    columnDrag: boolean;
+    columnResize: boolean;
+    rowResize: boolean;
+    rowDrag: boolean;
+    editable: boolean;
+    readOnly: boolean;
+    disableHover: boolean;
+    allowInsertRow: boolean;
+    allowManualInsertRow: boolean;
+    allowInsertColumn: boolean;
+    allowManualInsertColumn: boolean;
+    allowDeleteRow: boolean;
+    allowDeletingAllRows: boolean;
+    allowDeleteColumn: boolean;
+    allowRenameColumn: boolean;
+    allowComments: boolean;
+    wordWrap: boolean;
+    imageOptions: any;
+    csv: any;
+    csvFileName: string;
+    csvHeaders: boolean;
+    csvDelimiter: string;
+    parseTableFirstRowAsHeader: boolean;
+    parseTableAutoCellType: boolean;
+    selectionCopy: boolean;
+    toolbar: any;
+    search: boolean;
+    pagination: boolean;
+    paginationOptions: any;
+    fullscreen: boolean;
+    lazyLoading: boolean;
+    loadingSpin: boolean;
+    tableOverflow: boolean;
+    tableHeight: string;
+    tableWidth: any;
+    meta: any;
+    style: any;
+    parseFormulas: boolean;
+    autoIncrement: boolean;
+    autoCasting: boolean;
+    secureFormulas: boolean;
+    stripHTML: boolean;
+    stripHTMLOnCopy: boolean;
+    filters: boolean;
+    footers: any;
+    onundo: any;
+    onredo: any;
+    onload: any;
+    onchange: any;
+    oncomments: any;
+    onbeforechange: any;
+    onafterchanges: any;
+    onbeforeinsertrow: any;
+    oninsertrow: any;
+    onbeforeinsertcolumn: any;
+    oninsertcolumn: any;
+    onbeforedeleterow: any;
+    ondeleterow: any;
+    onbeforedeletecolumn: any;
+    ondeletecolumn: any;
+    onmoverow: any;
+    onmovecolumn: any;
+    onresizerow: any;
+    onresizecolumn: any;
+    onsort: any;
+    onselection: any;
+    oncopy: any;
+    onpaste: any;
+    onbeforepaste: any;
+    onmerge: any;
+    onfocus: any;
+    onblur: any;
+    onchangeheader: any;
+    oncreateeditor: any;
+    oneditionstart: any;
+    oneditionend: any;
+    onchangestyle: any;
+    onchangemeta: any;
+    onchangepage: any;
+    onbeforesave: any;
+    onsave: any;
+    onevent: any;
+    persistance: boolean;
+    updateTable: any;
+    detachForUpdates: boolean;
+    freezeColumns: any;
+    text: {
+        noRecordsFound: string;
+        showingPage: string;
+        show: string;
+        search: string;
+        entries: string;
+        columnName: string;
+        insertANewColumnBefore: string;
+        insertANewColumnAfter: string;
+        deleteSelectedColumns: string;
+        renameThisColumn: string;
+        orderAscending: string;
+        orderDescending: string;
+        insertANewRowBefore: string;
+        insertANewRowAfter: string;
+        deleteSelectedRows: string;
+        editComments: string;
+        addComments: string;
+        comments: string;
+        clearComments: string;
+        copy: string;
+        paste: string;
+        saveAs: string;
+        about: string;
+        areYouSureToDeleteTheSelectedRows: string;
+        areYouSureToDeleteTheSelectedColumns: string;
+        thisActionWillDestroyAnyExistingMergedCellsAreYouSure: string;
+        thisActionWillClearYourSearchResultsAreYouSure: string;
+        thereIsAConflictWithAnotherMergedCell: string;
+        invalidMergeProperties: string;
+        cellAlreadyMerged: string;
+        noCellsSelected: string;
+    };
+};
+export type Config = typeof defaultconfig;