Changeset 3754379

vtables/trunk/dist/spa/css/vtables.css

-              r3576926
+              r3754379
+:root {
+  --red: #f44336;
+  --red-1: #ffebee;
+  --red-2: #ffcdd2;
+  --red-3: #ef9a9a;
+  --red-4: #e57373;
+  --red-5: #ef5350;
+  --red-6: #f44336;
+  --red-7: #e53935;
+  --red-8: #d32f2f;
+  --red-9: #c62828;
+  --red-10: #b71c1c;
+  --red-11: #ff8a80;
+  --red-12: #ff5252;
+  --red-13: #ff1744;
+  --red-14: #d50000;
+  --pink: #e91e63;
+  --pink-1: #fce4ec;
+  --pink-2: #f8bbd0;
+  --pink-3: #f48fb1;
+  --pink-4: #f06292;
+  --pink-5: #ec407a;
+  --pink-6: #e91e63;
+  --pink-7: #d81b60;
+  --pink-8: #c2185b;
+  --pink-9: #ad1457;
+  --pink-10: #880e4f;
+  --pink-11: #ff80ab;
+  --pink-12: #ff4081;
+  --pink-13: #f50057;
+  --pink-14: #c51162;
+  --purple: #9c27b0;
+  --purple-1: #f3e5f5;
+  --purple-2: #e1bee7;
+  --purple-3: #ce93d8;
+  --purple-4: #ba68c8;
+  --purple-5: #ab47bc;
+  --purple-6: #9c27b0;
+  --purple-7: #8e24aa;
+  --purple-8: #7b1fa2;
+  --purple-9: #6a1b9a;
+  --purple-10: #4a148c;
+  --purple-11: #ea80fc;
+  --purple-12: #e040fb;
+  --purple-13: #d500f9;
+  --purple-14: #aa00ff;
+  --deep-purple: #673ab7;
+  --deep-purple-1: #ede7f6;
+  --deep-purple-2: #d1c4e9;
+  --deep-purple-3: #b39ddb;
+  --deep-purple-4: #9575cd;
+  --deep-purple-5: #7e57c2;
+  --deep-purple-6: #673ab7;
+  --deep-purple-7: #5e35b1;
+  --deep-purple-8: #512da8;
+  --deep-purple-9: #4527a0;
+  --deep-purple-10: #311b92;
+  --deep-purple-11: #b388ff;
+  --deep-purple-12: #7c4dff;
+  --deep-purple-13: #651fff;
+  --deep-purple-14: #6200ea;
+  --indigo: #3f51b5;
+  --indigo-1: #e8eaf6;
+  --indigo-2: #c5cae9;
+  --indigo-3: #9fa8da;
+  --indigo-4: #7986cb;
+  --indigo-5: #5c6bc0;
+  --indigo-6: #3f51b5;
+  --indigo-7: #3949ab;
+  --indigo-8: #303f9f;
+  --indigo-9: #283593;
+  --indigo-10: #1a237e;
+  --indigo-11: #8c9eff;
+  --indigo-12: #536dfe;
+  --indigo-13: #3d5afe;
+  --indigo-14: #304ffe;
+  --blue: #2196f3;
+  --blue-1: #e3f2fd;
+  --blue-2: #bbdefb;
+  --blue-3: #90caf9;
+  --blue-4: #64b5f6;
+  --blue-5: #42a5f5;
+  --blue-6: #2196f3;
+  --blue-7: #1e88e5;
+  --blue-8: #1976d2;
+  --blue-9: #1565c0;
+  --blue-10: #0d47a1;
+  --blue-11: #82b1ff;
+  --blue-12: #448aff;
+  --blue-13: #2979ff;
+  --blue-14: #2962ff;
+  --light-blue: #03a9f4;
+  --light-blue-1: #e1f5fe;
+  --light-blue-2: #b3e5fc;
+  --light-blue-3: #81d4fa;
+  --light-blue-4: #4fc3f7;
+  --light-blue-5: #29b6f6;
+  --light-blue-6: #03a9f4;
+  --light-blue-7: #039be5;
+  --light-blue-8: #0288d1;
+  --light-blue-9: #0277bd;
+  --light-blue-10: #01579b;
+  --light-blue-11: #80d8ff;
+  --light-blue-12: #40c4ff;
+  --light-blue-13: #00b0ff;
+  --light-blue-14: #0091ea;
+  --cyan: #00bcd4;
+  --cyan-1: #e0f7fa;
+  --cyan-2: #b2ebf2;
+  --cyan-3: #80deea;
+  --cyan-4: #4dd0e1;
+  --cyan-5: #26c6da;
+  --cyan-6: #00bcd4;
+  --cyan-7: #00acc1;
+  --cyan-8: #0097a7;
+  --cyan-9: #00838f;
+  --cyan-10: #006064;
+  --cyan-11: #84ffff;
+  --cyan-12: #18ffff;
+  --cyan-13: #00e5ff;
+  --cyan-14: #00b8d4;
+  --teal: #009688;
+  --teal-1: #e0f2f1;
+  --teal-2: #b2dfdb;
+  --teal-3: #80cbc4;
+  --teal-4: #4db6ac;
+  --teal-5: #26a69a;
+  --teal-6: #009688;
+  --teal-7: #00897b;
+  --teal-8: #00796b;
+  --teal-9: #00695c;
+  --teal-10: #004d40;
+  --teal-11: #a7ffeb;
+  --teal-12: #64ffda;
+  --teal-13: #1de9b6;
+  --teal-14: #00bfa5;
+  --green: #4caf50;
+  --green-1: #e8f5e9;
+  --green-2: #c8e6c9;
+  --green-3: #a5d6a7;
+  --green-4: #81c784;
+  --green-5: #66bb6a;
+  --green-6: #4caf50;
+  --green-7: #43a047;
+  --green-8: #388e3c;
+  --green-9: #2e7d32;
+  --green-10: #1b5e20;
+  --green-11: #b9f6ca;
+  --green-12: #69f0ae;
+  --green-13: #00e676;
+  --green-14: #00c853;
+  --light-green: #8bc34a;
+  --light-green-1: #f1f8e9;
+  --light-green-2: #dcedc8;
+  --light-green-3: #c5e1a5;
+  --light-green-4: #aed581;
+  --light-green-5: #9ccc65;
+  --light-green-6: #8bc34a;
+  --light-green-7: #7cb342;
+  --light-green-8: #689f38;
+  --light-green-9: #558b2f;
+  --light-green-10: #33691e;
+  --light-green-11: #ccff90;
+  --light-green-12: #b2ff59;
+  --light-green-13: #76ff03;
+  --light-green-14: #64dd17;
+  --lime: #cddc39;
+  --lime-1: #f9fbe7;
+  --lime-2: #f0f4c3;
+  --lime-3: #e6ee9c;
+  --lime-4: #dce775;
+  --lime-5: #d4e157;
+  --lime-6: #cddc39;
+  --lime-7: #c0ca33;
+  --lime-8: #afb42b;
+  --lime-9: #9e9d24;
+  --lime-10: #827717;
+  --lime-11: #f4ff81;
+  --lime-12: #eeff41;
+  --lime-13: #c6ff00;
+  --lime-14: #aeea00;
+  --yellow: #ffeb3b;
+  --yellow-1: #fffde7;
+  --yellow-2: #fff9c4;
+  --yellow-3: #fff59d;
+  --yellow-4: #fff176;
+  --yellow-5: #ffee58;
+  --yellow-6: #ffeb3b;
+  --yellow-7: #fdd835;
+  --yellow-8: #fbc02d;
+  --yellow-9: #f9a825;
+  --yellow-10: #f57f17;
+  --yellow-11: #ffff8d;
+  --yellow-12: #ffff00;
+  --yellow-13: #ffea00;
+  --yellow-14: #ffd600;
+  --amber: #ffc107;
+  --amber-1: #fff8e1;
+  --amber-2: #ffecb3;
+  --amber-3: #ffe082;
+  --amber-4: #ffd54f;
+  --amber-5: #ffca28;
+  --amber-6: #ffc107;
+  --amber-7: #ffb300;
+  --amber-8: #ffa000;
+  --amber-9: #ff8f00;
+  --amber-10: #ff6f00;
+  --amber-11: #ffe57f;
+  --amber-12: #ffd740;
+  --amber-13: #ffc400;
+  --amber-14: #ffab00;
+  --orange: #ff9800;
+  --orange-1: #fff3e0;
+  --orange-2: #ffe0b2;
+  --orange-3: #ffcc80;
+  --orange-4: #ffb74d;
+  --orange-5: #ffa726;
+  --orange-6: #ff9800;
+  --orange-7: #fb8c00;
+  --orange-8: #f57c00;
+  --orange-9: #ef6c00;
+  --orange-10: #e65100;
+  --orange-11: #ffd180;
+  --orange-12: #ffab40;
+  --orange-13: #ff9100;
+  --orange-14: #ff6d00;
+  --deep-orange: #ff5722;
+  --deep-orange-1: #fbe9e7;
+  --deep-orange-2: #ffccbc;
+  --deep-orange-3: #ffab91;
+  --deep-orange-4: #ff8a65;
+  --deep-orange-5: #ff7043;
+  --deep-orange-6: #ff5722;
+  --deep-orange-7: #f4511e;
+  --deep-orange-8: #e64a19;
+  --deep-orange-9: #d84315;
+  --deep-orange-10: #bf360c;
+  --deep-orange-11: #ff9e80;
+  --deep-orange-12: #ff6e40;
+  --deep-orange-13: #ff3d00;
+  --deep-orange-14: #dd2c00;
+  --brown: #795548;
+  --brown-1: #efebe9;
+  --brown-2: #d7ccc8;
+  --brown-3: #bcaaa4;
+  --brown-4: #a1887f;
+  --brown-5: #8d6e63;
+  --brown-6: #795548;
+  --brown-7: #6d4c41;
+  --brown-8: #5d4037;
+  --brown-9: #4e342e;
+  --brown-10: #3e2723;
+  --brown-11: #d7ccc8;
+  --brown-12: #bcaaa4;
+  --brown-13: #8d6e63;
+  --brown-14: #5d4037;
+  --grey: #9e9e9e;
+  --grey-1: #fafafa;
+  --grey-2: #f5f5f5;
+  --grey-3: #eeeeee;
+  --grey-4: #e0e0e0;
+  --grey-5: #bdbdbd;
+  --grey-6: #9e9e9e;
+  --grey-7: #757575;
+  --grey-8: #616161;
+  --grey-9: #424242;
+  --grey-10: #212121;
+  --grey-11: #f5f5f5;
+  --grey-12: #eeeeee;
+  --grey-13: #bdbdbd;
+  --grey-14: #616161;
+  --blue-grey: #607d8b;
+  --blue-grey-1: #eceff1;
+  --blue-grey-2: #cfd8dc;
+  --blue-grey-3: #b0bec5;
+  --blue-grey-4: #90a4ae;
+  --blue-grey-5: #78909c;
+  --blue-grey-6: #607d8b;
+  --blue-grey-7: #546e7a;
+  --blue-grey-8: #455a64;
+  --blue-grey-9: #37474f;
+  --blue-grey-10: #263238;
+  --blue-grey-11: #cfd8dc;
+  --blue-grey-12: #b0bec5;
+  --blue-grey-13: #78909c;
+  --blue-grey-14: #455a64;
+}
+body.q-body--prevent-scroll {
+  position: initial !important;
+}
 #wpcontent {
   padding: 20px;
 …
 .gap-5 {
   gap: 5px;
+}
+.gap-10 {
+  gap: 10px;
+}
 …
+}
+#adminmenu #toplevel_page_vtables .wp-menu-image img {
+  opacity: 1;
+}
+.q-table td,
+.q-table th {
+  white-space: normal;
+  word-wrap: break-word;
+}
+#q-notify .row {
+  padding-top: 0;
+  padding-bottom: 0;
+}
+/* ===== TheTable styles ===== */
+.q-item__section--avatar {
+  min-width: unset;
+}
+.settings-open {
+  margin-right: 325px;
+}
+.fullscreen .q-table__top {
+  padding: 0;
+}
+.fullscreen .q-table__top .vtable__top {
+  padding: 12px 16px;
+}
+.fullscreen.q-table--dense .vtable__top {
+  padding: 8px 16px;
+}
+.cell-value {
+  display: block;
+  white-space: initial;
+  width: inherit;
+}
+.q-table--cell-separator .q-table__top {
+  border-bottom: none !important;
+}
+.q-table--cell-separator .q-table__top .vtable__top {
+  border-bottom: 1px solid rgba(0, 0, 0, 0.12);
+}
+.vtable {
+  margin: 10px 0;
+}
+.vtable .q-table__bottom {
+  padding: 0;
+}
+.vtable .q-table__bottom > div {
+  border-radius: 0 0 4px 4px;
+  padding: 4px 10px 4px 10px;
+  min-height: inherit;
+}
+.vtable .q-table__bottom--nodata {
+  padding-left: 10px;
+  padding-right: 10px;
+}
+.vtable .q-field__bottom {
+  padding-left: 0;
+  padding-right: 0;
+  position: absolute;
+  background: #fff;
+}
+.vtable .q-table__top {
+  padding: 0;
+  overflow: hidden;
+}
+.vtable .q-table__top > div {
+  padding: 12px 16px;
+  min-height: inherit;
+}
+.vtable .q-table--dense .q-table__top {
+  padding: 0;
+  overflow: hidden;
+}
+.vtable .q-table--dense .q-table__top > div {
+  padding: 8px 16px;
+  min-height: inherit;
+}
+.edit-icon {
+  position: absolute;
+}
+.q-td .edit-icon {
+  top: -8px;
+}
+/* Quasar makes body cells positioned, header cells not — the edit icon needs
+   the th as its containing block. */
+.q-table thead th {
+  position: relative;
+}
+.q-table thead th .edit-icon {
+  top: -6px;
+}
+.vtable__top h1 {
+  display: inline-block;
+  position: relative;
+}
+.vtable__top h1 .edit-icon {
+  top: -10px;
+  right: -45px;
+}
+.vtable__top:hover .edit-icon,
+.q-td:hover .edit-icon,
+.q-table thead th:hover .edit-icon,
+.q-item__section:hover .edit-icon {
+  display: block !important;
+}
+.admin-bar-presented-on-fullscreen {
+  margin-top: 30px;
+  margin-left: 160px;
+}
+.fullscreen-btn {
+  height: 40px;
+  width: 40px;
+}
+.v-enter-active,
+.v-leave-active {
+  transition: opacity 0.5s ease;
+}
+.v-enter-from,
+.v-leave-to {
+  opacity: 0;
+}
+.q-table th.sortable {
+  cursor: pointer;
+  min-width: 116px;
+}
+.cell-raw-html > * {
+  cursor: pointer;
+}
+.q-table__container {
+  margin: 2px;
+}
+.pre-wrap {
+  white-space: pre-wrap;
+}
+.flex-no-wrap {
+  flex-wrap: nowrap;
+}

vtables/trunk/dist/spa/index.html

r3576926	r3754379
1		<!DOCTYPE html><html><head><title>vTables</title><meta charset=utf-8><meta name=description content="Create stunning, interactive tables effortlessly. No coding required. The ultimate WordPress plugin, lets you design powerful tables in a few clicks. Transform your data visualization now."><meta name=format-detection content="telephone=no"><meta name=msapplication-tap-highlight content=no><meta name=viewport content="user-scalable=no,initial-scale=1,maximum-scale=1,minimum-scale=1,width=device-width"> <script type="module" crossorigin src="/./wp-content/plugins/vtables/dist/spa/assets/index.fd5ac4ef.js"></script>
2		<link rel="stylesheet" href="~~/./wp-content/plugins/vtables/dist/spa/assets/index.92adfbea~~.css">
	1	<!DOCTYPE html><html><head><title>vTables</title><meta charset=utf-8><meta name=description content="Build interactive data tables from CSV, Excel and JSON files, or from scratch, and embed them anywhere with a shortcode."><meta name=format-detection content="telephone=no"><meta name=msapplication-tap-highlight content=no><meta name=viewport content="user-scalable=no,initial-scale=1,maximum-scale=1,minimum-scale=1,width=device-width"> <script type="module" crossorigin src="./assets/index.88166ef6.js"></script>
	2	<link rel="stylesheet" href="./assets/index.64481c02.css">
3	3	</head><body><div id=q-app></div></body></html>

vtables/trunk/includes/Classes/Activator.php

-              r3133736
+              r3754379
 /**
  * ACTIVATOR CLASS
+ * @since 1.0.0
+ *
+ * Owns the schema shared with vTables Pro: wp_vtables (one row per table) and
+ * wp_vtables_source (one row per data row). Definitions are kept identical to
+ * Pro's Activator so either plugin can create or upgrade them and the other
+ * keeps working on the result. Pro-only tables (the WooCommerce product
+ * index) are left to Pro. Every step is idempotent.
  */
 class Activator {
 …
      */
     public function vtables_migrate_databases($network_wide = false) {
+        global $wpdb;
+        if ($network_wide) {
+            // Retrieve all site IDs from this network (WordPress >= 4.6 provides easy to use functions for that).
+            if (function_exists('get_sites') && function_exists('get_current_network_id')) {
+                $site_ids = get_sites(array('fields' => 'ids', 'network_id' => get_current_network_id()));
+            } else {
+                $site_ids = $wpdb->get_col("SELECT blog_id FROM $wpdb->blogs WHERE site_id = $wpdb->siteid;");
+            }
+            // Install the plugin for all these sites.
+        if ($network_wide && is_multisite()) {
+            $site_ids = get_sites(array('fields' => 'ids', 'network_id' => get_current_network_id()));
             foreach ($site_ids as $site_id) {
                 switch_to_blog($site_id);
 …
      */
     private function vtables_migrate() {
+      $this->vtables_create_main_table();
+        $this->vtables_create_main_table();
+        $this->vtables_create_source_table();
+        $this->vtables_update_table_type_values();
+    }
     /**
      * CREATE MAIN TABLE
+     * 0.1.x/0.2.x created wp_vtables without table_type, woocommerce_categories
+     * and plan; they are added in place. 'plan' is NOT backfilled here: rows
+     * that predate it stay NULL so vTables Pro can grandfather them by their
+     * source type and license (vtables_pro_backfill_table_plans). Tables
+     * created by this plugin are stamped 'free' on insert.
      */
     public function vtables_create_main_table() {
 …
             id int(10) NOT NULL AUTO_INCREMENT,
             title text NULL DEFAULT NULL,
+            table_type text NULL DEFAULT NULL,
+            woocommerce_categories JSON,
             settings json NULL DEFAULT NULL,
             file_size text NULL DEFAULT NULL,
 …
             updated_at timestamp NULL DEFAULT CURRENT_TIMESTAMP,
             source longtext NULL DEFAULT NULL,
+            plan text NULL DEFAULT NULL,
             PRIMARY KEY (id)
             ) $charset_collate;";
+          ) $charset_collate;";
         $this->vtables_run_sql($sql, $table_name);
         $this->vtables_add_new_column($table_name, 'table_type', 'TEXT');
         $this->vtables_add_new_column($table_name, 'woocommerce_categories', 'JSON');
+        $this->vtables_add_new_column($table_name, 'plan', 'TEXT');
+    }
+    /**
+     * CREATE SOURCE TABLE
+     * One row per imported data row, keyed by table_id, so large datasets stay
+     * out of the single wp_vtables.source longtext cell (and under the
+     * max_allowed_packet ceiling).
+     */
+    public function vtables_create_source_table() {
+        global $wpdb;
+        $charset_collate = $wpdb->get_charset_collate();
+        $table_name = $wpdb->prefix . 'vtables_source';
+        $sql = "CREATE TABLE $table_name (
+            id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
+            table_id int(10) NOT NULL,
+            row_index int(10) unsigned NOT NULL,
+            row_json longtext NULL DEFAULT NULL,
+            search_blob longtext NULL DEFAULT NULL,
+            PRIMARY KEY (id),
+            KEY table_id_row_index (table_id, row_index)
+          ) $charset_collate;";
+        $this->vtables_run_sql($sql, $table_name);
+        // For tables created by early vTables Pro 0.3.x, before search_blob existed.
+        $this->vtables_add_new_column($table_name, 'search_blob', 'TEXT');
+        $this->vtables_upgrade_source_indexes($table_name);
+    }
+    /**
+     * UPGRADE SOURCE INDEX SLOTS
+     * 5 typed "slot" sub-columns (text + numeric) with composite indexes, plus
+     * a FULLTEXT index on search_blob. This plugin writes search_blob and the
+     * slot values on every row write (vtables_replace_source_rows), so the rows
+     * are ready for vTables Pro's server-side search/sort without a reindex.
+     */
+    private function vtables_upgrade_source_indexes($table_name) {
+        for ($k = 1; $k <= 5; $k++) {
+            $this->vtables_add_typed_column($table_name, "idx_{$k}_txt", 'VARCHAR(191) NULL DEFAULT NULL');
+            $this->vtables_add_typed_column($table_name, "idx_{$k}_num", 'DECIMAL(30,10) NULL DEFAULT NULL');
+        }
+        for ($k = 1; $k <= 5; $k++) {
+            $this->vtables_add_index($table_name, "idx_{$k}_txt", "(table_id, idx_{$k}_txt)");
+            $this->vtables_add_index($table_name, "idx_{$k}_num", "(table_id, idx_{$k}_num)");
+        }
+        $this->vtables_add_fulltext_index($table_name, 'ft_search_blob', 'search_blob');
+    }
+    /**
+     * UPDATE LEGACY TABLE_TYPE VALUES
+     * 0.1.0–0.1.4 stored 'local' (now 'csv') and 'remote' (now
+     * 'google_sheets'). The frontend and vTables Pro only know the current names.
+     */
+    private function vtables_update_table_type_values() {
+        global $wpdb;
+        $wpdb->query($wpdb->prepare( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+            "UPDATE {$wpdb->prefix}vtables SET table_type = %s WHERE table_type = %s",
+            'csv',
+            'local'
+        ));
+        $wpdb->query($wpdb->prepare( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+            "UPDATE {$wpdb->prefix}vtables SET table_type = %s WHERE table_type = %s",
+            'google_sheets',
+            'remote'
+        ));
+    }
+    /**
+     * ADD TYPED COLUMN
+     * maybe_add_column() only takes the column name, so we guard with SHOW
+     * COLUMNS ourselves to keep DECIMAL/VARCHAR definitions intact.
+     */
+    private function vtables_add_typed_column($table_name, $column, $definition) {
+        global $wpdb;
+        $exists = $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+            $wpdb->prepare('SHOW COLUMNS FROM `' . esc_sql($table_name) . '` LIKE %s', $wpdb->esc_like($column))
+        );
+        if ($exists) {
+            return;
+        }
+        $wpdb->query("ALTER TABLE `$table_name` ADD `$column` $definition"); // phpcs:ignore WordPress.DB.DirectDatabaseQuery, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.SchemaChange, PluginCheck.Security.DirectDB.UnescapedDBParameter -- DDL; the table, column and definition are fixed values from vtables_upgrade_source_indexes()
+    }
+    /**
+     * ADD INDEX (idempotent)
+     */
+    private function vtables_add_index($table_name, $index_name, $columns_sql) {
+        global $wpdb;
+        $exists = $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+            $wpdb->prepare('SHOW INDEX FROM `' . esc_sql($table_name) . '` WHERE Key_name = %s', $index_name)
+        );
+        if ($exists) {
+            return;
+        }
+        $wpdb->query("ALTER TABLE `$table_name` ADD KEY `$index_name` $columns_sql"); // phpcs:ignore WordPress.DB.DirectDatabaseQuery, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.SchemaChange, PluginCheck.Security.DirectDB.UnescapedDBParameter -- DDL; the table, index and columns are fixed values from vtables_upgrade_source_indexes()
+    }
+    /**
+     * ADD FULLTEXT INDEX (idempotent)
+     * May fail on very old / non-InnoDB engines; the rest of the migration
+     * still completes (LIKE search remains the correctness path).
+     */
+    private function vtables_add_fulltext_index($table_name, $index_name, $column) {
+        global $wpdb;
+        $exists = $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+            $wpdb->prepare('SHOW INDEX FROM `' . esc_sql($table_name) . '` WHERE Key_name = %s', $index_name)
+        );
+        if ($exists) {
+            return;
+        }
+        $wpdb->query("ALTER TABLE `$table_name` ADD FULLTEXT KEY `$index_name` (`$column`)"); // phpcs:ignore WordPress.DB.DirectDatabaseQuery, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.SchemaChange, PluginCheck.Security.DirectDB.UnescapedDBParameter -- DDL; the table, index and column are fixed values from vtables_upgrade_source_indexes()
+    }
 …
      * RUN SQL
      */
     private function vtables_run_sql($sql, $tableName) {
         global $wpdb;
         if ($wpdb->get_var("SHOW TABLES LIKE '$tableName'") != $tableName) {
             require_once(ABSPATH . 'wp-admin/includes/upgrade.php');
+    private function vtables_run_sql($sql, $table_name) {
+        global $wpdb;
+        if ($wpdb->get_var($wpdb->prepare('SHOW TABLES LIKE %s', $wpdb->esc_like($table_name))) !== $table_name) { // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+            require_once ABSPATH . 'wp-admin/includes/upgrade.php';
             dbDelta($sql);
+        }
 …
      * ADD NEW COLUMN
      */
     function vtables_add_new_column($tableName, $tableColumn, $columnType) {
       if ($columnType === 'JSON') {
         $create_ddl = "ALTER TABLE $tableName ADD $tableColumn JSON;";
       } else {
         $create_ddl = "ALTER TABLE $tableName ADD $tableColumn TEXT NULL DEFAULT NULL;";
+      }
       require_once(ABSPATH . 'wp-admin/includes/upgrade.php');
       maybe_add_column($tableName, $tableColumn, $create_ddl);
+    private function vtables_add_new_column($table_name, $column, $column_type) {
+        if ($column_type === 'JSON') {
+            $create_ddl = "ALTER TABLE $table_name ADD $column JSON;";
+        } else {
+            $create_ddl = "ALTER TABLE $table_name ADD $column TEXT NULL DEFAULT NULL;";
+        }
+        require_once ABSPATH . 'wp-admin/includes/upgrade.php';
+        maybe_add_column($table_name, $column, $create_ddl);
+    }
+}

vtables/trunk/includes/Classes/LoadAssets.php

-              r3576926
+              r3754379
 if ( ! defined( 'ABSPATH' ) ) exit;
+/**
+ * GET HASHED VUE FILES
+ */
+function vtables_get_hashed_file($name, $type) {
+  if ($name === 'index') {
+    $index_html = VTABLES_DIR . 'dist/spa/index.html';
+    if (is_file($index_html)) {
+      $html = file_get_contents($index_html);
+      if ($html !== false && preg_match('#assets/(index\.[A-Za-z0-9]+\.' . preg_quote($type, '#') . ')#', $html, $m)) {
+        return $m[1];
+      }
+class LoadAssets {
+  /**
+   * DEV MODE
+   * env.php (never shipped, see release.sh) switches the admin screen and the
+   * embed document to the Quasar dev server:
+   *
+   *   define( 'VTABLES_MODE', 'dev' );
+   *   define( 'VTABLES_BASE_URL', 'http://localhost:9000' );
+   */
+  public static function is_dev_mode() {
+    $env_file_path = VTABLES_DIR . 'env.php';
+    if ( file_exists( $env_file_path ) ) {
+      include_once $env_file_path;
+    }
+    return defined( 'VTABLES_MODE' ) && constant( 'VTABLES_MODE' ) === 'dev' && defined( 'VTABLES_BASE_URL' );
+  }
+  $folder = VTABLES_DIR . 'dist/spa/assets/';
+  $files = list_files($folder);
+  $matchedFiles = [];
+  // Filter and store all matching files
+  foreach ( $files as $file ) {
+      if ( is_file( $file ) && strpos(basename($file), $name) !== false ) {
+          $filetype = wp_check_filetype($file);
+          if ($filetype['ext'] === $type) {
+              $matchedFiles[] = $file;
+          }
+      }
+  }
+  // If multiple files match, sort them to get a consistent result
+  if (count($matchedFiles) > 1) {
+      usort($matchedFiles, function($a, $b) {
+          return strcmp(basename($b), basename($a));
+      });
+  }
+  // Return the first matched file
+  return isset($matchedFiles[0]) ? basename($matchedFiles[0]) : null;
+}
+/**
+ * LOAD ASSETS CLASS
+ */
+class LoadAssets {
+  /**
+   * ADD TYPE ATTR
+   * The SPA entry is an ES module.
+   */
   public function add_type_attribute( $tag, $handle, $src ) {
     if ( 'vtables-index' !== $handle ) {
       return $tag;
+    if ( $handle === 'vtables-script-boot' || $handle === 'vtables-index' ) {
+      $tag = str_replace( '<script ', '<script type="module" ', $tag );
+    }
-    $tag = str_replace('<script ', '<script type="module" ', $tag);
     return $tag;
+  }
-  public function vtables_enqueue_assets() {
-    $env_file_path = VTABLES_DIR . 'env.php';
+    if (file_exists($env_file_path)) {
+      include($env_file_path);
+      $vtables_mode = constant('VTABLES_MODE');
+  /**
+   * GET HASHED VUE FILES
+   *
+   * Vite emits <name>.<hash>.<ext> into dist/spa/assets, so the filename is only
+   * known at runtime. dist/spa/index.html is the authority on which of them is
+   * the entry: Vite writes the real filenames into it and
+   * scripts/patch-asset-base.mjs rewrites them to ./assets/<name>.<hash>.<ext>.
+   *
+   * Do NOT pick a name out of the directory listing instead. The pattern
+   * index.*.js is ambiguous even on a clean build — the entry chunk and a lazy
+   * index chunk both match — and an update unpacked over an older install (FTP
+   * or a file manager overwrites files but never deletes the ones that went
+   * away) leaves both builds' hashes side by side.
+   *
+   * glob() stays as the fallback for a dist/spa without index.html, ordered by
+   * mtime and then size so the newest build's entry chunk still wins.
+   *
+   * Results are memoized per request.
+   */
+  public function vtables_get_hashed_file( $name, $type ) {
+    static $cache = array();
+    $key = $name . '.' . $type;
+    if ( array_key_exists( $key, $cache ) ) {
+      return $cache[ $key ];
+    }
     if (isset($vtables_mode) && $vtables_mode === 'dev') { // dev mode
+    $file = $this->vtables_hashed_file_from_manifest( $name, $type );
+      wp_enqueue_style('vtables-material-icons', VTABLES_URL . 'public/css/material-icons-font-dist.css', false, VTABLES_VERSION);
+      wp_enqueue_script('vtables-script-boot', constant('VTABLES_BASE_URL') . '/.quasar/client-entry.js', array('jquery'), null, true);
+    if ( $file === null ) {
+      $file = $this->vtables_hashed_file_from_glob( $name, $type );
+    }
     } else { // prod mode
+    $cache[ $key ] = $file;
+      wp_enqueue_style( 'vtables-material-icons', VTABLES_URL . 'dist/spa/css/material-icons-font-dist.css', false, VTABLES_VERSION);
+    return $file;
+  }
-      $app_css = VTABLES_URL . 'dist/spa/assets/' . vtables_get_hashed_file('index', 'css');
-      wp_enqueue_style( 'vtables-index', $app_css, false, VTABLES_VERSION);
+      wp_localize_script(
+        'wp-api',
+        'WP_API_Settings',
+        array(
+          'nonce' => wp_create_nonce('wp_rest'),
+          'base_url' => rest_url(),
+        )
+      );
+      wp_enqueue_script('wp-api');
+  /**
+   * HASHED FILE FROM THE BUILD MANIFEST
+   * dist/spa/index.html as written by Vite — the only place that says which
+   * hash belongs to the current build.
+   */
+  private function vtables_hashed_file_from_manifest( $name, $type ) {
+    $manifest = VTABLES_DIR . 'dist/spa/index.html';
+      $app_js = VTABLES_URL . 'dist/spa/assets/' . vtables_get_hashed_file('index', 'js');
+      wp_enqueue_script( 'vtables-index', $app_js, array('jquery'), VTABLES_VERSION, false);
+    if ( ! is_readable( $manifest ) ) {
+      return null;
+    }
       add_filter( 'script_loader_tag', array( $this, 'add_type_attribute' ), 10, 3 );
+    $html = file_get_contents( $manifest ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_get_contents_file_get_contents -- local build file
+    if ( ! is_string( $html ) || $html === '' ) {
+      return null;
+    }
+    // Case-sensitive on purpose: 'index' must not match 'IndexPage.<hash>.js'.
+    $pattern = '#assets/(' . preg_quote( $name, '#' ) . '\.[A-Za-z0-9_-]+\.' . preg_quote( $type, '#' ) . ')#';
+    return preg_match( $pattern, $html, $matches ) ? $matches[1] : null;
+  }
+  /**
+   * HASHED FILE FROM THE DIRECTORY LISTING
+   * Fallback only. Newest build first, then the largest file: chunks from one
+   * build share an mtime (an unpacked zip gives them all the same one) and the
+   * entry is by far the biggest of them.
+   */
+  private function vtables_hashed_file_from_glob( $name, $type ) {
+    $matched = glob( VTABLES_DIR . 'dist/spa/assets/' . $name . '.*.' . $type );
+    if ( ! is_array( $matched ) || empty( $matched ) ) {
+      return null;
+    }
+    if ( count( $matched ) > 1 ) {
+      usort( $matched, function ( $a, $b ) {
+        $by_mtime = filemtime( $b ) <=> filemtime( $a );
+        if ( $by_mtime !== 0 ) {
+          return $by_mtime;
+        }
+        $by_size = filesize( $b ) <=> filesize( $a );
+        return $by_size !== 0 ? $by_size : strcmp( basename( $b ), basename( $a ) );
+      } );
+    }
+    return basename( $matched[0] );
+  }
+  /**
+   * ENQUEUE ASSETS: for admin page
+   */
+  public function vtables_enqueue_assets_admin() {
+    $sys_info = $this->vtables_get_sys_info( 'admin' );
+    if ( self::is_dev_mode() ) {
+      wp_enqueue_style( 'vtables-material-icons', VTABLES_URL . 'public/css/material-icons-font-dist.css', array(), VTABLES_VERSION );
+      wp_enqueue_style( 'vtables-css', VTABLES_URL . 'public/css/vtables.css', array(), VTABLES_VERSION );
+      wp_enqueue_script( 'vtables-script-boot', constant( 'VTABLES_BASE_URL' ) . '/.quasar/client-entry.js', array(), VTABLES_VERSION, true );
+      wp_localize_script( 'vtables-script-boot', 'vtables_sys_info', $sys_info );
+    } else {
+      wp_enqueue_style( 'vtables-material-icons', VTABLES_URL . 'dist/spa/css/material-icons-font-dist.css', array(), VTABLES_VERSION );
+      wp_enqueue_style( 'vtables-css', VTABLES_URL . 'public/css/vtables.css', array(), VTABLES_VERSION );
+      // A missing hash would enqueue the assets directory itself; skip instead,
+      // so a broken dist fails as a missing script rather than a 403/404 on a
+      // directory URL.
+      $index_css = $this->vtables_get_hashed_file( 'index', 'css' );
+      if ( $index_css ) {
+        wp_enqueue_style( 'vtables-index', VTABLES_URL . 'dist/spa/assets/' . $index_css, array(), null ); // phpcs:ignore WordPress.WP.EnqueuedResourceParameters.MissingVersion -- hashed build filename
+      }
+      $index_js = $this->vtables_get_hashed_file( 'index', 'js' );
+      if ( $index_js ) {
+        wp_enqueue_script( 'vtables-index', VTABLES_URL . 'dist/spa/assets/' . $index_js, array(), null, false ); // phpcs:ignore WordPress.WP.EnqueuedResourceParameters.MissingVersion -- hashed build filename
+        wp_localize_script( 'vtables-index', 'vtables_sys_info', $sys_info );
+      }
+    }
+    add_filter( 'script_loader_tag', array( $this, 'add_type_attribute' ), 10, 3 );
+  }
+  /**
+   * GET SYS INFO
+   * 'front' is printed into the embed document (the public SPA reads its own
+   * window first, see src/boot/wpapi.ts); 'admin' adds the nonce and upload
+   * limit for the admin screen.
+   */
+  public function vtables_get_sys_info( $page_type = 'front' ) {
+    $arr_params = array(
+      'ajaxurl'     => admin_url( 'admin-ajax.php' ),
+      'plain_links' => empty( get_option( 'permalink_structure' ) ),
+      'locale'      => ( is_admin() && function_exists( 'get_user_locale' ) ) ? get_user_locale() : get_locale(),
+      'pro_url'     => 'https://vtables.pro',
+    );
+    if ( $page_type === 'admin' ) {
+      $arr_params['nonce']           = wp_create_nonce( 'vtables_nonce' );
+      $arr_params['max_upload_size'] = wp_max_upload_size();
+    }
+    return apply_filters( 'vtables_sys_info', $arr_params, $page_type );
+  }
+}

vtables/trunk/includes/autoload.php

-              r3036822
+              r3754379
      * Plugin autoloader.
+     *
      * Pattern (with or without <Subnamespace>):
      *  <Namespace>/<Subnamespace>.../Class_Name (or Classname)
      *  'includes/subdir.../class-name.php' or '...classname.php'
+     * Maps vTables\<Subnamespace>\<Class> to includes/<Subnamespace>/<Class>.php.
+     * The namespace separator is part of the match, so vTables Pro's
+     * vTablesPro\ classes are never resolved here.
+     *
+     * @since 3.0.0
+     *
+     * @param $class
+     * @param string $class
      */
     function vtables_autoload($class)
+    {
+        // Do not load unless in plugin domain.
+        $namespace = 'vTables';
+        $namespace = 'vTables\\';
         if (strpos($class, $namespace) !== 0) {
             return;
+        }
-        // Remove the root namespace.
         $unprefixed = substr($class, strlen($namespace));
+        // Build the file path.
+        $file_path = str_replace('\\', DIRECTORY_SEPARATOR, $unprefixed);
+        $file      = dirname(__FILE__) . $file_path . '.php';
+        $file_path  = str_replace('\\', DIRECTORY_SEPARATOR, $unprefixed);
+        $file       = __DIR__ . DIRECTORY_SEPARATOR . $file_path . '.php';
         if (file_exists($file)) {
 …
+        }
+    }
+    // Register the autoloader.
     spl_autoload_register('vtables_autoload');
+}

vtables/trunk/includes/endpoints.php

-              r3576926
+              r3754379
 /**
+ * GET ALL TABLES.
+ */
+add_action( 'rest_api_init', function () {
+  register_rest_route( 'vtables/v1', '/tables', array(
+    'methods' => 'GET',
+    'callback' => 'vtables_get_all_handler',
+    'args' => [
+      'page' => [
+        'description' => 'Current page',
+        'type' => "integer",
+      ],
+      'per_page' => [
+        'description' => 'Items per page',
+        'type' => "integer",
+      ],
+      'search' => [
+        'description' => 'Search items',
+        'type' => "string",
+      ]
+    ],
+    'permission_callback' => '__return_true',
+  ) );
+} );
+function vtables_get_all_handler( WP_REST_Request $data ) {
+ * LIST TABLES.
+ */
+add_action('wp_ajax_vtables_list_tables', 'vtables_list_tables_handler');
+function vtables_list_tables_handler() {
+  vtables_require_admin_ajax();
   global $wpdb;
+  $table_name = $wpdb->prefix . 'vtables';
+  $limit = $data['per_page'];
+  $offset = ($data['page'] - 1) * $data['per_page'];
+  $search = $data['search'] ?? '';
+  $allowed_orderby = array('created_at', 'updated_at', 'title', 'table_type');
+  $limit   = isset($_GET['per_page']) ? max(1, min(100, intval($_GET['per_page']))) : 10; // phpcs:ignore WordPress.Security.NonceVerification
+  $page    = isset($_GET['page']) ? max(1, intval($_GET['page'])) : 1; // phpcs:ignore WordPress.Security.NonceVerification
+  $offset  = ($page - 1) * $limit;
+  $search  = isset($_GET['search']) ? sanitize_text_field(wp_unslash($_GET['search'])) : ''; // phpcs:ignore WordPress.Security.NonceVerification
+  $orderby = isset($_GET['orderby']) && in_array(sanitize_text_field(wp_unslash($_GET['orderby'])), $allowed_orderby, true) // phpcs:ignore WordPress.Security.NonceVerification
+    ? sanitize_text_field(wp_unslash($_GET['orderby'])) // phpcs:ignore WordPress.Security.NonceVerification
+    : 'created_at';
+  $order   = isset($_GET['order']) && in_array(strtoupper(sanitize_text_field(wp_unslash($_GET['order']))), array('ASC', 'DESC'), true) // phpcs:ignore WordPress.Security.NonceVerification
+    ? strtoupper(sanitize_text_field(wp_unslash($_GET['order']))) // phpcs:ignore WordPress.Security.NonceVerification
+    : 'DESC';
   $keyword = $wpdb->esc_like($search);
+  $orderby = isset($data['orderby']) ? $data['orderby'] : 'created_at';
+  $order = isset($data['order']) && in_array($data['order'], ['ASC', 'DESC']) ? $data['order'] : 'DESC';
+  $search_by_title_query = $wpdb->prepare(
+    "SELECT * FROM $table_name WHERE title LIKE %s",
+    '%' . $keyword . '%'
+  $total = (int) $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $wpdb->prepare( "SELECT COUNT(*) FROM {$wpdb->prefix}vtables WHERE title LIKE %s", '%' . $keyword . '%' )
   );
+  $pagination_query = $wpdb->prepare(
+    "SELECT * FROM $table_name WHERE title LIKE %s ORDER BY $orderby $order LIMIT $limit OFFSET $offset",
+    '%' . $keyword . '%'
+  // $orderby and $order are allowlisted above; sanitize_sql_orderby() keeps
+  // the clause SQL-safe on its own.
+  $order_sql = sanitize_sql_orderby("$orderby $order");
+  $results = $wpdb->get_results( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $wpdb->prepare( "SELECT * FROM {$wpdb->prefix}vtables WHERE title LIKE %s ORDER BY $order_sql LIMIT %d OFFSET %d", '%' . $keyword . '%', $limit, $offset ) // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared
   );
+  $total = $wpdb->get_results($search_by_title_query);
+  $results = $wpdb->get_results($pagination_query);
+  if (!$results) {
+    new WP_Error( 'TABLES_NOT_FOUND', 'Tables Not found.', array( 'status' => 404 ) );
+  if ($wpdb->last_error) {
+    vtables_send_db_error();
+  }
 …
     $item->settings = json_decode($item->settings);
     $item->source = json_decode($item->source);
+  }
+  $response = array();
+  $response['tables'] = $results;
+  $response['total'] = count($total);
+  $rest_response = new WP_REST_Response(
+    // Pro-only tables (see vtables_table_requires_pro): the list shows them
+    // (their data is untouched) but they can't be opened here.
+    $item->requires_pro = vtables_table_requires_pro($item);
+    unset($item->woocommerce_categories, $item->plan);
+    if ($item->table_type === 'importing') {
+      $transient = get_transient('vtables_import_' . $item->id);
+      if ($transient) {
+        $item->import_progress = array(
+          'imported_rows' => intval($transient['imported_rows']),
+          'total_rows'    => intval($transient['total_rows']),
+        );
+      }
+    }
+  }
+  $response             = array();
+  $response['tables']   = $results;
+  $response['total']    = $total;
+  wp_send_json($response);
+}
+/**
+ * DB ERROR RESPONSE
+ * The raw $wpdb->last_error describes the schema and query; it goes to the
+ * debug log (when enabled), never to the client.
+ */
+function vtables_send_db_error() {
+  global $wpdb;
+  if (defined('WP_DEBUG') && WP_DEBUG && $wpdb->last_error) {
+    error_log('vTables DB error: ' . $wpdb->last_error); // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log
+  }
+  wp_send_json(array('code' => 500, 'error' => 'DB_ERROR', 'message' => 'Database error.'), 500);
+}
+/**
+ * STANDARD GUARDS
+ * Every admin action: valid vtables_nonce on an AJAX request, manage_options.
+ */
+function vtables_require_admin_ajax() {
+  if (
+    !check_ajax_referer('vtables_nonce', 'security', false) ||
+    !defined('DOING_AJAX') ||
+    !DOING_AJAX
+  ) {
+    wp_send_json(array('code' => 400, 'error' => 'INVALID_REQUEST', 'message' => 'Invalid request.'), 400);
+  }
+  if (!current_user_can('manage_options')) {
+    wp_send_json(array('code' => 403, 'error' => 'PERMISSION_DENIED', 'message' => 'Permission denied.'), 403);
+  }
+}
+/**
+ * REJECT PRO-ONLY TABLES (AJAX GUARD)
+ * Google Sheets / external / WooCommerce tables, and tables with a saved row
+ * filter (see vtables_table_requires_pro), are left untouched for vTables
+ * Pro — none of the read/edit endpoints serve them here.
+ */
+function vtables_reject_pro_table($table_id) {
+  if (vtables_table_requires_pro(vtables_table_meta($table_id))) {
+    wp_send_json(array('code' => 403, 'error' => 'REQUIRES_PRO', 'message' => 'This table requires vTables Pro.'), 403);
+  }
+}
+/**
+ * FETCH TABLE BY ID.
+ */
+add_action('wp_ajax_vtables_fetch_table', 'vtables_fetch_table_handler');
+add_action('wp_ajax_nopriv_vtables_fetch_table', 'vtables_fetch_table_handler');
+function vtables_fetch_table_handler() {
+  if (!defined('DOING_AJAX') || !DOING_AJAX) {
+    wp_send_json(array('code' => 400, 'error' => 'INVALID_REQUEST', 'message' => 'Invalid request.'), 400);
+  }
+  if (empty($_GET['id'])) { // phpcs:ignore WordPress.Security.NonceVerification
+    wp_send_json(array('code' => 400, 'error' => 'MISSING_REQUIRED_FIELDS', 'message' => 'Missing required fields.'), 400);
+  }
+  global $wpdb;
+  $id = intval($_GET['id']); // phpcs:ignore WordPress.Security.NonceVerification
+  $table = $wpdb->get_row( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $wpdb->prepare( "SELECT * FROM {$wpdb->prefix}vtables WHERE id = %d", $id )
+  );
+  if (!$table) {
+    wp_send_json(array('code' => 404, 'error' => 'TABLE_NOT_FOUND', 'message' => 'Table by ID not found.'), 404);
+  }
+  // Pro-only sources / saved row filter: metadata only.
+  if (vtables_table_requires_pro($table)) {
+    wp_send_json(array(
+      'id'           => (int) $table->id,
+      'title'        => $table->title,
+      'table_type'   => $table->table_type,
+      'requires_pro' => true,
+      'settings'     => null,
+      'source'       => array('columns' => array(), 'rows' => array()),
+    ));
+  }
+  $table->settings     = json_decode($table->settings);
+  $table->source       = json_decode($table->source);
+  $table->requires_pro = false;
+  unset($table->woocommerce_categories, $table->plan);
+  // Rows live in wp_vtables_source (one record per data row). Legacy tables
+  // (rows still inside the source cell, not yet moved by the background
+  // migration) have no records here, so their source->rows stay as a fallback.
+  $row_count = (int) $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $wpdb->prepare( "SELECT COUNT(*) FROM {$wpdb->prefix}vtables_source WHERE table_id = %d", $id )
+  );
+  if ($row_count > 0) {
+    if (!is_object($table->source)) {
+      $table->source = new stdClass();
+    }
+    // ALWAYS SERVER MODE for tables whose rows live in wp_vtables_source: the
+    // SPA pages through vtables_query_rows instead of loading every row.
+    $per_page = vtables_default_per_page();
+    $first_page = vtables_query_source_rows(array(
+      'table_id' => $id,
+      'page'     => 1,
+      'per_page' => $per_page,
+    ));
+    $table->server_mode  = true;
+    $table->total_rows   = $row_count;
+    $table->source->rows = array();
+    $table->first_page   = $first_page['rows'];
+    $table->per_page     = $per_page;
+  }
+  wp_send_json($table);
+}
+/**
+ * Find a title that doesn't collide with an existing row, appending
+ * -copy, -copy-2, -copy-3, ... until unique. A single -copy check only
+ * survives one duplication; duplicating the same title again would
+ * collide with the previous "-copy" row, so this keeps incrementing.
+ */
+function vtables_generate_unique_title($wpdb, $table_name, $title) {
+  if (!$title) {
+    return $title;
+  }
+  $candidate = $title;
+  $suffix    = 1;
+  while (
+    $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+      $wpdb->prepare("SELECT id FROM $table_name WHERE title = %s", $candidate) // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared
+    )
+  ) {
+    $candidate = $suffix === 1 ? $title . '-copy' : $title . '-copy-' . $suffix;
+    $suffix++;
+  }
+  return $candidate;
+}
+/**
+ * Seed settings.columns.visibleColumns from the parsed column list when the
+ * incoming settings carry no explicit show/hide selection (both lists empty
+ * or missing). The renderer treats an empty visibleColumns as "show all",
+ * but the Settings → Columns toggles bind to it directly, so a table stored
+ * with an empty list shows every toggle off and one click hides everything.
+ * Legacy uploaders seed this client-side; the chunked/stream import paths
+ * send INITIAL_SETTINGS verbatim, so it has to happen here.
+ */
+function vtables_seed_visible_columns($settings_json, $columns) {
+  $decoded = json_decode((string) $settings_json, true);
+  if (!is_array($decoded)) {
+    return $settings_json;
+  }
+  $cols    = isset($decoded['columns']) && is_array($decoded['columns']) ? $decoded['columns'] : array();
+  $visible = isset($cols['visibleColumns']) && is_array($cols['visibleColumns']) ? $cols['visibleColumns'] : array();
+  $hidden  = isset($cols['hiddenColumns']) && is_array($cols['hiddenColumns']) ? $cols['hiddenColumns'] : array();
+  if (!empty($visible) || !empty($hidden)) {
+    return $settings_json;
+  }
+  $names = array();
+  foreach ((array) $columns as $col) {
+    if (is_array($col) && isset($col['name']) && $col['name'] !== '') {
+      $names[] = (string) $col['name'];
+    }
+  }
+  if (empty($names)) {
+    return $settings_json;
+  }
+  $cols['visibleColumns'] = $names;
+  $cols['hiddenColumns']  = array();
+  $decoded['columns']     = $cols;
+  $encoded = wp_json_encode($decoded);
+  return $encoded !== false ? $encoded : $settings_json;
+}
+/**
+ * CREATE TABLE.
+ */
+add_action('wp_ajax_vtables_create_table', 'vtables_create_table_handler');
+function vtables_create_table_handler() {
+  vtables_require_admin_ajax();
+  global $wpdb;
+  $table_name = $wpdb->prefix . 'vtables';
+  $title      = isset($_POST['title']) ? sanitize_text_field(wp_unslash($_POST['title'])) : ''; // phpcs:ignore WordPress.Security.NonceVerification
+  $source     = isset($_POST['source']) ? wp_unslash($_POST['source']) : '{}'; // phpcs:ignore WordPress.Security.NonceVerification, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- JSON, decoded below
+  $file_size  = isset($_POST['file_size']) ? sanitize_text_field(wp_unslash($_POST['file_size'])) : ''; // phpcs:ignore WordPress.Security.NonceVerification
+  $settings   = isset($_POST['settings']) ? wp_unslash($_POST['settings']) : '{}'; // phpcs:ignore WordPress.Security.NonceVerification, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- JSON, filtered below
+  $table_type = isset($_POST['table_type']) ? sanitize_key(wp_unslash($_POST['table_type'])) : ''; // phpcs:ignore WordPress.Security.NonceVerification
+  // Only file/manual sources are created here; the other sources are vTables Pro's.
+  if (!in_array($table_type, vtables_free_table_types(), true)) {
+    wp_send_json(array('code' => 403, 'error' => 'REQUIRES_PRO', 'message' => 'This data source requires vTables Pro.'), 403);
+  }
+  // Settings go through the same Free settings policy as every save, so a
+  // crafted payload can't seed Pro-only settings onto a new table.
+  $settings = vtables_filter_settings_for_free($settings, '{}');
+  $title = vtables_generate_unique_title($wpdb, $table_name, $title);
+  // Split source: keep {columns, rows:[]} in wp_vtables; store the rows in
+  // wp_vtables_source via the shared helper. Keeps a single read path in fetch_table
+  // and keeps large datasets out of the one longtext cell.
+  $source_rows = array();
+  $source_decoded = json_decode($source, true);
+  if (!is_array($source_decoded)) {
+    wp_send_json(array('code' => 400, 'error' => 'INVALID_SOURCE', 'message' => 'Invalid table source.'), 400);
+  }
+  if (isset($source_decoded['rows']) && is_array($source_decoded['rows'])) {
+    $source_rows = $source_decoded['rows'];
+  }
+  $source_decoded['rows'] = array();
+  $source_to_store = wp_json_encode($source_decoded);
+  if ($source_to_store !== false) {
+    $source = $source_to_store;
+  }
+  $result = $wpdb->insert( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $table_name,
     array(
+      'success' => !!$results,
+      'data' => $response,
+      'title'      => $title,
+      'source'     => $source,
+      'file_size'  => $file_size,
+      'settings'   => $settings,
+      'table_type' => $table_type,
+      // Stamped like vTables Pro stamps tables created without a license, so
+      // Pro later treats it as the Free-plan table it is.
+      'plan'       => 'free',
+    )
   );
+  vtables_maybe_send_nocache_headers($rest_response);
+  return $rest_response;
+}
+/**
+ * GET TABLE BY ID.
+ */
+add_action( 'rest_api_init', function () {
+  register_rest_route( 'vtables/v1', '/tables/(?P<id>\d+)', array(
+    'methods' => 'GET',
+    'callback' => 'vtables_get_by_id_handler',
+    'permission_callback' => '__return_true',
+  ) );
+} );
+function vtables_get_by_id_handler( WP_REST_Request $data ) {
+  if ($result === false) {
+    wp_send_json(array('code' => 500, 'error' => 'DB_ERROR', 'message' => 'Failed to create record.'), 500);
+  }
+  $new_table_id = $wpdb->insert_id;
+  if (!empty($source_rows)) {
+    vtables_replace_source_rows($new_table_id, $source_rows);
+  }
+  wp_send_json(array('id' => $new_table_id));
+}
+/**
+ * SAVE TABLE CHANGES.
+ */
+add_action('wp_ajax_vtables_save_source', 'vtables_save_source_handler');
+function vtables_save_source_handler() {
+  vtables_require_admin_ajax();
   global $wpdb;
   $table_name = $wpdb->prefix . 'vtables';
+  $id = $data['id'];
+  $query = $wpdb->prepare("SELECT * FROM $table_name WHERE id = %d", $id);
+  $results = $wpdb->get_results($query);
+  if (empty($results)) {
+    return new WP_Error( 'TABLE_NOT_FOUND', 'Table by ID not found.', array( 'status' => 404 ) );
+  }
+  $results[0]->settings = json_decode($results[0]->settings);
+  $results[0]->source = json_decode($results[0]->source);
+  $response = $results[0];
+  $rest_response = new WP_REST_Response(
+  $id        = isset($_POST['id']) ? intval($_POST['id']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  $title     = isset($_POST['title']) ? sanitize_text_field(wp_unslash($_POST['title'])) : ''; // phpcs:ignore WordPress.Security.NonceVerification
+  $source    = isset($_POST['source']) ? wp_unslash($_POST['source']) : ''; // phpcs:ignore WordPress.Security.NonceVerification, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- JSON, decoded below
+  $file_size = isset($_POST['fileSize']) ? sanitize_text_field(wp_unslash($_POST['fileSize'])) : ''; // phpcs:ignore WordPress.Security.NonceVerification
+  if (!$id) {
+    wp_send_json(array('code' => 400, 'error' => 'MISSING_REQUIRED_FIELDS', 'message' => 'Missing required fields.'), 400);
+  }
+  if (!vtables_table_exists($id)) {
+    wp_send_json(array('code' => 404, 'error' => 'TABLE_NOT_FOUND', 'message' => 'Table not found.'), 404);
+  }
+  vtables_reject_pro_table($id);
+  // Update only title
+  if ($title && empty($source)) {
+    $result = $wpdb->update( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+      $table_name,
+      array(
+        'title'      => $title,
+        'updated_at' => current_time('mysql'),
+      ),
+      array('id' => $id)
+    );
+    wp_send_json($result);
+  }
+  // Split source: persist {columns, rows:[]} on wp_vtables, store rows in
+  // wp_vtables_source. (Still bounded by post_max_size on the incoming request —
+  // pre-existing; fully addressed by the per-row edit endpoints in Phase 2.)
+  $source_rows = array();
+  $source_decoded = json_decode($source, true);
+  if (is_array($source_decoded)) {
+    if (isset($source_decoded['rows']) && is_array($source_decoded['rows'])) {
+      $source_rows = $source_decoded['rows'];
+    }
+    $source_decoded['rows'] = array();
+    $source_to_store = wp_json_encode($source_decoded);
+    if ($source_to_store !== false) {
+      $source = $source_to_store;
+    }
+  }
+  // Update source
+  $result = $wpdb->update( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $table_name,
     array(
+      'success' => !!$results,
+      'data' => $response,
+      'title'      => $title,
+      'file_size'  => $file_size,
+      'source'     => $source,
+      'updated_at' => current_time('mysql'),
+    ),
+    array('id' => $id),
+    array('%s', '%s', '%s', '%s'),
+    array('%d')
+  );
+  // Only replace stored rows when the payload actually carries rows. In server
+  // mode the client holds only one page, so source.rows is empty here — replacing
+  // would destroy the dataset. Per-row edits go through the dedicated endpoints.
+  if (!empty($source_rows)) {
+    vtables_replace_source_rows($id, $source_rows);
+  }
+  $updated_table = $wpdb->get_row( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $wpdb->prepare( "SELECT * FROM {$wpdb->prefix}vtables WHERE id = %d", $id )
+  );
+  $updated_table->source = json_decode($updated_table->source);
+  // Reattach saved rows so the response mirrors the submitted source.
+  if (!empty($source_rows)) {
+    if (!is_object($updated_table->source)) {
+      $updated_table->source = new stdClass();
+    }
+    $updated_table->source->rows = json_decode(wp_json_encode($source_rows));
+  }
+  wp_send_json($updated_table);
+}
+/**
+ * SAVE TABLE SETTINGS.
+ */
+add_action('wp_ajax_vtables_save_settings', 'vtables_save_settings_handler');
+function vtables_save_settings_handler() {
+  vtables_require_admin_ajax();
+  global $wpdb;
+  $table_name = $wpdb->prefix . 'vtables';
+  $id         = isset($_POST['id']) ? intval($_POST['id']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  $settings   = isset($_POST['settings']) ? wp_unslash($_POST['settings']) : '{}'; // phpcs:ignore WordPress.Security.NonceVerification, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- JSON, filtered below
+  $updated_at = current_time('mysql');
+  if (!$id) {
+    wp_send_json(array('code' => 400, 'error' => 'MISSING_REQUIRED_FIELDS', 'message' => 'Missing required fields.'), 400);
+  }
+  $table_row = $wpdb->get_row( $wpdb->prepare( "SELECT id, table_type, settings FROM {$wpdb->prefix}vtables WHERE id = %d", $id ) ); // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+  if ($table_row === null) {
+    wp_send_json(array('code' => 404, 'error' => 'TABLE_NOT_FOUND', 'message' => 'Table not found.'), 404);
+  }
+  vtables_reject_pro_table($id);
+  // Settings that belong to vTables Pro keep their stored values: this plugin
+  // neither adds nor erases them (see includes/settings-policy.php), so a
+  // table's Pro settings survive editing here and apply again under Pro.
+  $settings = vtables_filter_settings_for_free($settings, (string) $table_row->settings);
+  $wpdb->update( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $table_name,
+    array(
+      'settings'   => $settings,
+      'updated_at' => $updated_at,
+    ),
+    array('id' => $id),
+    array('%s', '%s'),
+    array('%d')
+  );
+  wp_send_json(array('updated_at' => $updated_at));
+}
+/**
+ * DELETE TABLE.
+ */
+add_action('wp_ajax_vtables_delete_table', 'vtables_delete_table_handler');
+function vtables_delete_table_handler() {
+  vtables_require_admin_ajax();
+  if (empty($_POST['id'])) { // phpcs:ignore WordPress.Security.NonceVerification
+    wp_send_json(array('code' => 400, 'error' => 'MISSING_REQUIRED_FIELDS', 'message' => 'Missing table ID.'), 400);
+  }
+  global $wpdb;
+  $table_name = $wpdb->prefix . 'vtables';
+  $id = intval($_POST['id']); // phpcs:ignore WordPress.Security.NonceVerification
+  // $wpdb->delete() returns 0 (not false) for a row that was never there, so
+  // without this the caller gets an indistinguishable 200 for a bogus id.
+  if (!vtables_table_exists($id)) {
+    wp_send_json(array('code' => 404, 'error' => 'TABLE_NOT_FOUND', 'message' => 'Table not found.'), 404);
+  }
+  $result = $wpdb->delete( $table_name, array('id' => $id) ); // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+  if ($result === false) {
+    wp_send_json(array('code' => 500, 'error' => 'DB_ERROR', 'message' => 'Failed to delete table.'), 500);
+  }
+  // Remove the table's rows so we don't orphan records in wp_vtables_source.
+  $wpdb->delete( $wpdb->prefix . 'vtables_source', array('table_id' => $id), array('%d') ); // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+  wp_send_json(array('id' => $id));
+}
+/**
+ * PARSE EXCEL FILE.
+ */
+add_action('wp_ajax_vtables_parse_excel', 'vtables_parse_excel_handler');
+function vtables_parse_excel_handler() {
+  vtables_require_admin_ajax();
+  if (!isset($_FILES['file']['error'], $_FILES['file']['name'], $_FILES['file']['size'], $_FILES['file']['tmp_name']) || $_FILES['file']['error'] !== UPLOAD_ERR_OK) { // phpcs:ignore WordPress.Security.NonceVerification
+    wp_send_json(array('code' => 400, 'error' => 'MISSING_FILE', 'message' => 'No file uploaded or upload error.'), 400);
+  }
+  $allowed_extensions = array('xlsx', 'xls');
+  $file_name          = sanitize_file_name(wp_unslash($_FILES['file']['name'])); // phpcs:ignore WordPress.Security.NonceVerification
+  $extension          = strtolower(pathinfo($file_name, PATHINFO_EXTENSION));
+  if (!in_array($extension, $allowed_extensions, true)) {
+    wp_send_json(array('code' => 400, 'error' => 'INVALID_FILE_TYPE', 'message' => 'Only .xlsx and .xls files are allowed.'), 400);
+  }
+  $max_size = 52428800; // 50 MB
+  if (intval($_FILES['file']['size']) > $max_size) { // phpcs:ignore WordPress.Security.NonceVerification
+    wp_send_json(array('code' => 400, 'error' => 'FILE_TOO_LARGE', 'message' => 'File exceeds the 50 MB size limit.'), 400);
+  }
+  $temp_dir = vtables_uploads_dir();
+  if (!$temp_dir) {
+    wp_send_json(array('code' => 500, 'error' => 'UPLOAD_DIR_ERROR', 'message' => 'Could not create upload directory.'), 500);
+  }
+  $temp_file = vtables_store_uploaded_file($_FILES['file'], $temp_dir, wp_unique_filename($temp_dir, $file_name)); // phpcs:ignore WordPress.Security.NonceVerification, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- validated by wp_handle_upload()
+  if (!$temp_file) {
+    wp_send_json(array('code' => 500, 'error' => 'FILE_MOVE_ERROR', 'message' => 'Could not move uploaded file.'), 500);
+  }
+  $raw_rows = array();
+  if ($extension === 'xlsx') {
+    $xlsx = \Shuchkin\SimpleXLSX::parse($temp_file);
+    if (!$xlsx) {
+      wp_delete_file($temp_file);
+      wp_send_json(array('code' => 500, 'error' => 'PARSE_ERROR', 'message' => 'Failed to parse .xlsx file.'), 500);
+    }
+    $raw_rows = $xlsx->rows();
+  } else {
+    $xls = \Shuchkin\SimpleXLS::parse($temp_file);
+    if (!$xls) {
+      wp_delete_file($temp_file);
+      wp_send_json(array('code' => 500, 'error' => 'PARSE_ERROR', 'message' => 'Failed to parse .xls file.'), 500);
+    }
+    $raw_rows = $xls->rows();
+  }
+  wp_delete_file($temp_file);
+  if (empty($raw_rows)) {
+    wp_send_json(array('code' => 400, 'error' => 'EMPTY_FILE', 'message' => 'The file contains no data.'), 400);
+  }
+  $headers = array_shift($raw_rows);
+  $columns = array();
+  foreach ($headers as $header) {
+    $name      = (string) $header;
+    $columns[] = array('name' => $name, 'label' => $name);
+  }
+  $rows = array();
+  foreach ($raw_rows as $raw_row) {
+    // Skip entirely empty rows.
+    $non_empty = array_filter($raw_row, function($v) { return $v !== '' && $v !== null; });
+    if (empty($non_empty)) {
+      continue;
+    }
+    $row_data = array();
+    foreach ($headers as $index => $header) {
+      $row_data[(string) $header] = isset($raw_row[$index]) ? $raw_row[$index] : '';
+    }
+    $rows[] = $row_data;
+  }
+  wp_send_json(array('columns' => $columns, 'rows' => $rows));
+}
+/**
+ * UPLOAD CHUNK.
+ * Accepts one binary chunk of a large file and stores it to disk.
+ */
+add_action('wp_ajax_vtables_upload_chunk', 'vtables_upload_chunk_handler');
+function vtables_upload_chunk_handler() {
+  vtables_require_admin_ajax();
+  // Validate and sanitize inputs.
+  $session_id   = isset($_POST['session_id']) ? sanitize_text_field(wp_unslash($_POST['session_id'])) : ''; // phpcs:ignore WordPress.Security.NonceVerification
+  $chunk_index  = isset($_POST['chunk_index']) ? intval($_POST['chunk_index']) : -1; // phpcs:ignore WordPress.Security.NonceVerification
+  $total_chunks = isset($_POST['total_chunks']) ? intval($_POST['total_chunks']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  if (!preg_match('/^[0-9a-f\-]{36}$/i', $session_id) || $chunk_index < 0 || $total_chunks < 1) {
+    wp_send_json(array('code' => 400, 'error' => 'INVALID_PARAMS', 'message' => 'Invalid parameters.'), 400);
+  }
+  if (!isset($_FILES['file']['error'], $_FILES['file']['name'], $_FILES['file']['size'], $_FILES['file']['tmp_name']) || $_FILES['file']['error'] !== UPLOAD_ERR_OK) { // phpcs:ignore WordPress.Security.NonceVerification
+    wp_send_json(array('code' => 400, 'error' => 'MISSING_FILE', 'message' => 'No file chunk uploaded or upload error.'), 400);
+  }
+  // Chunk must not exceed the server upload limit on its own.
+  if (intval($_FILES['file']['size']) > wp_max_upload_size()) { // phpcs:ignore WordPress.Security.NonceVerification
+    wp_send_json(array('code' => 400, 'error' => 'CHUNK_TOO_LARGE', 'message' => 'Chunk exceeds server upload limit.'), 400);
+  }
+  $uploads_dir = vtables_uploads_dir();
+  $chunk_dir   = $uploads_dir ? $uploads_dir . 'chunks/' . $session_id . '/' : '';
+  if (!$uploads_dir || !wp_mkdir_p($chunk_dir)) {
+    wp_send_json(array('code' => 500, 'error' => 'UPLOAD_DIR_ERROR', 'message' => 'Could not create chunk directory.'), 500);
+  }
+  if (!vtables_store_uploaded_file($_FILES['file'], $chunk_dir, 'chunk_' . $chunk_index)) { // phpcs:ignore WordPress.Security.NonceVerification, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- validated by wp_handle_upload()
+    wp_send_json(array('code' => 500, 'error' => 'FILE_MOVE_ERROR', 'message' => 'Could not store chunk.'), 500);
+  }
+  wp_send_json(array('received' => $chunk_index));
+}
+/**
+ * FINALIZE UPLOAD.
+ * Assembles chunks, extracts column headers, creates a table skeleton with
+ * table_type = 'importing', and persists import state in a WP transient.
+ */
+add_action('wp_ajax_vtables_finalize_upload', 'vtables_finalize_upload_handler');
+function vtables_finalize_upload_handler() {
+  vtables_require_admin_ajax();
+  $session_id              = isset($_POST['session_id'])             ? sanitize_text_field(wp_unslash($_POST['session_id'])) : ''; // phpcs:ignore WordPress.Security.NonceVerification
+  $file_name               = isset($_POST['file_name'])              ? sanitize_file_name(wp_unslash($_POST['file_name'])) : ''; // phpcs:ignore WordPress.Security.NonceVerification
+  $title                   = isset($_POST['title'])                   ? sanitize_text_field(wp_unslash($_POST['title'])) : ''; // phpcs:ignore WordPress.Security.NonceVerification
+  $total_chunks            = isset($_POST['total_chunks'])            ? intval($_POST['total_chunks']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  $file_size               = isset($_POST['file_size'])              ? sanitize_text_field(wp_unslash($_POST['file_size'])) : ''; // phpcs:ignore WordPress.Security.NonceVerification
+  $settings                = isset($_POST['settings'])               ? wp_unslash($_POST['settings']) : '{}'; // phpcs:ignore WordPress.Security.NonceVerification, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- JSON, filtered below
+  $original_type_override  = isset($_POST['original_type'])          ? sanitize_key(wp_unslash($_POST['original_type'])) : ''; // phpcs:ignore WordPress.Security.NonceVerification
+  // The override may only name another file/manual type.
+  if ($original_type_override !== '' && !in_array($original_type_override, vtables_free_table_types(), true)) {
+    $original_type_override = '';
+  }
+  if (!preg_match('/^[0-9a-f\-]{36}$/i', $session_id) || !$file_name || $total_chunks < 1) {
+    wp_send_json(array('code' => 400, 'error' => 'INVALID_PARAMS', 'message' => 'Invalid parameters.'), 400);
+  }
+  $allowed_extensions = array('xlsx', 'xls', 'csv', 'json');
+  $extension          = strtolower(pathinfo($file_name, PATHINFO_EXTENSION));
+  if (!in_array($extension, $allowed_extensions, true)) {
+    wp_send_json(array('code' => 400, 'error' => 'INVALID_FILE_TYPE', 'message' => 'Unsupported file type.'), 400);
+  }
+  $assembled_dir = vtables_uploads_dir();
+  $chunk_dir     = $assembled_dir . 'chunks/' . $session_id . '/';
+  if (!$assembled_dir) {
+    wp_send_json(array('code' => 500, 'error' => 'UPLOAD_DIR_ERROR', 'message' => 'Could not create upload directory.'), 500);
+  }
+  // Assemble chunks in order.
+  $assembled_path = $assembled_dir . $session_id . '.' . $extension;
+  $out = fopen($assembled_path, 'wb'); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen
+  if (!$out) {
+    wp_send_json(array('code' => 500, 'error' => 'ASSEMBLE_ERROR', 'message' => 'Could not create assembled file.'), 500);
+  }
+  for ($i = 0; $i < $total_chunks; $i++) {
+    $chunk_file = $chunk_dir . 'chunk_' . $i;
+    if (!file_exists($chunk_file)) {
+      fclose($out); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose
+      wp_delete_file($assembled_path);
+      wp_send_json(array('code' => 400, 'error' => 'MISSING_CHUNK', 'message' => 'Missing chunk ' . $i . '.'), 400);
+    }
+    $chunk_data = file_get_contents($chunk_file); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_get_contents_file_get_contents
+    fwrite($out, $chunk_data); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite
+  }
+  fclose($out); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose
+  // Remove chunk directory.
+  vtables_remove_directory($chunk_dir);
+  // Hard 10 MB cap (defense in depth; the client rejects earlier). A larger
+  // assembled file is removed before any parser loads it into memory — a 10 MB
+  // xlsx can already expand to hundreds of MB inside SimpleXLSX on a 128 MB host.
+  if (filesize($assembled_path) > vtables_max_upload_bytes()) {
+    wp_delete_file($assembled_path);
+    wp_send_json(array('code' => 400, 'error' => 'FILE_TOO_LARGE', 'message' => 'File exceeds the 10 MB size limit.'), 400);
+  }
+  // Extract column headers, count rows, and collect a small sample for type
+  // sniffing (first ~200 data rows). $original_extension is kept before xlsx/xls
+  // (and now json) get normalized to a streamable CSV cache.
+  $columns            = array();
+  $total_rows         = 0;
+  $original_extension = $extension;
+  $sample_rows        = array();
+  $sample_limit       = 200;
+  if ($extension === 'xlsx') {
+    $xlsx = \Shuchkin\SimpleXLSX::parse($assembled_path);
+    if (!$xlsx) {
+      wp_delete_file($assembled_path);
+      wp_send_json(array('code' => 500, 'error' => 'PARSE_ERROR', 'message' => 'Failed to parse .xlsx file.'), 500);
+    }
+    $raw_rows = $xlsx->rows();
+    if (empty($raw_rows)) {
+      wp_delete_file($assembled_path);
+      wp_send_json(array('code' => 400, 'error' => 'EMPTY_FILE', 'message' => 'The file contains no data.'), 400);
+    }
+    $headers = array_shift($raw_rows);
+    foreach ($headers as $header) {
+      $name      = (string) $header;
+      $columns[] = array('name' => $name, 'label' => $name);
+    }
+    // Convert to a streamable CSV cache so each batch call reads O(batch) not O(total).
+    $csv_cache_path = $assembled_dir . $session_id . '_cache.csv';
+    $fh_out = fopen($csv_cache_path, 'w'); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen
+    if ($fh_out) {
+      fputcsv($fh_out, $headers); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite
+      $actual_rows = 0;
+      foreach ($raw_rows as $raw_row) {
+        $non_empty = array_filter($raw_row, function ($v) { return $v !== '' && $v !== null; });
+        if (empty($non_empty)) continue;
+        $padded = array();
+        $assoc  = array();
+        foreach ($headers as $idx => $h) {
+          $cell = isset($raw_row[$idx]) ? $raw_row[$idx] : '';
+          $padded[] = $cell;
+          $assoc[(string) $h] = $cell;
+        }
+        fputcsv($fh_out, $padded); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite
+        if (count($sample_rows) < $sample_limit) {
+          $sample_rows[] = $assoc;
+        }
+        $actual_rows++;
+      }
+      fclose($fh_out); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose
+      wp_delete_file($assembled_path);
+      $assembled_path = $csv_cache_path;
+      $extension      = 'csv';
+      $total_rows     = $actual_rows;
+    } else {
+      $total_rows = count($raw_rows);
+    }
+  } elseif ($extension === 'xls') {
+    $xls = \Shuchkin\SimpleXLS::parse($assembled_path);
+    if (!$xls) {
+      wp_delete_file($assembled_path);
+      wp_send_json(array('code' => 500, 'error' => 'PARSE_ERROR', 'message' => 'Failed to parse .xls file.'), 500);
+    }
+    $raw_rows = $xls->rows();
+    if (empty($raw_rows)) {
+      wp_delete_file($assembled_path);
+      wp_send_json(array('code' => 400, 'error' => 'EMPTY_FILE', 'message' => 'The file contains no data.'), 400);
+    }
+    $headers = array_shift($raw_rows);
+    foreach ($headers as $header) {
+      $name      = (string) $header;
+      $columns[] = array('name' => $name, 'label' => $name);
+    }
+    // Convert to a streamable CSV cache so each batch call reads O(batch) not O(total).
+    $csv_cache_path = $assembled_dir . $session_id . '_cache.csv';
+    $fh_out = fopen($csv_cache_path, 'w'); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen
+    if ($fh_out) {
+      fputcsv($fh_out, $headers); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite
+      $actual_rows = 0;
+      foreach ($raw_rows as $raw_row) {
+        $non_empty = array_filter($raw_row, function ($v) { return $v !== '' && $v !== null; });
+        if (empty($non_empty)) continue;
+        $padded = array();
+        $assoc  = array();
+        foreach ($headers as $idx => $h) {
+          $cell = isset($raw_row[$idx]) ? $raw_row[$idx] : '';
+          $padded[] = $cell;
+          $assoc[(string) $h] = $cell;
+        }
+        fputcsv($fh_out, $padded); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite
+        if (count($sample_rows) < $sample_limit) {
+          $sample_rows[] = $assoc;
+        }
+        $actual_rows++;
+      }
+      fclose($fh_out); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose
+      wp_delete_file($assembled_path);
+      $assembled_path = $csv_cache_path;
+      $extension      = 'csv';
+      $total_rows     = $actual_rows;
+    } else {
+      $total_rows = count($raw_rows);
+    }
+  } elseif ($extension === 'csv') {
+    $fh = fopen($assembled_path, 'r'); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen
+    if (!$fh) {
+      wp_delete_file($assembled_path);
+      wp_send_json(array('code' => 500, 'error' => 'PARSE_ERROR', 'message' => 'Could not open CSV file.'), 500);
+    }
+    $headers = fgetcsv($fh);
+    if (empty($headers)) {
+      fclose($fh); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose
+      wp_delete_file($assembled_path);
+      wp_send_json(array('code' => 400, 'error' => 'EMPTY_FILE', 'message' => 'The CSV file contains no data.'), 400);
+    }
+    foreach ($headers as $header) {
+      $name      = (string) $header;
+      $columns[] = array('name' => $name, 'label' => $name);
+    }
+    while (($csv_row = fgetcsv($fh)) !== false) {
+      if (count($sample_rows) < $sample_limit) {
+        $assoc = array();
+        foreach ($headers as $idx => $h) {
+          $assoc[(string) $h] = isset($csv_row[$idx]) ? $csv_row[$idx] : '';
+        }
+        $sample_rows[] = $assoc;
+      }
+      $total_rows++;
+    }
+    fclose($fh); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose
+  } elseif ($extension === 'json') {
+    $raw_content = file_get_contents($assembled_path); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_get_contents_file_get_contents
+    $decoded     = json_decode($raw_content, true);
+    if (!is_array($decoded) || empty($decoded)) {
+      wp_delete_file($assembled_path);
+      wp_send_json(array('code' => 400, 'error' => 'EMPTY_FILE', 'message' => 'The JSON file contains no data.'), 400);
+    }
+    $first_item = reset($decoded);
+    if (!is_array($first_item)) {
+      wp_delete_file($assembled_path);
+      wp_send_json(array('code' => 400, 'error' => 'INVALID_FORMAT', 'message' => 'JSON must be an array of objects.'), 400);
+    }
+    $headers = array_keys($first_item);
+    foreach ($headers as $key) {
+      $name      = (string) $key;
+      $columns[] = array('name' => $name, 'label' => $name);
+    }
+    // Normalize JSON to the same streamable CSV cache that xlsx/xls produce so
+    // import_rows_batch never re-decodes the whole file on every batch (it just
+    // streams the CSV). Falls back to raw JSON if the cache can't be written.
+    $csv_cache_path = $assembled_dir . $session_id . '_cache.csv';
+    $fh_out = fopen($csv_cache_path, 'w'); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen
+    if ($fh_out) {
+      fputcsv($fh_out, $headers); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite
+      $actual_rows = 0;
+      foreach ($decoded as $item) {
+        if (!is_array($item)) continue;
+        $padded = array();
+        $assoc  = array();
+        foreach ($headers as $h) {
+          $cell = isset($item[$h]) ? $item[$h] : '';
+          // Flatten nested values so the CSV cell stays scalar; import re-keys by header.
+          if (is_array($cell)) {
+            $cell = wp_json_encode($cell);
+          }
+          $padded[] = $cell;
+          $assoc[(string) $h] = $cell;
+        }
+        fputcsv($fh_out, $padded); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite
+        if (count($sample_rows) < $sample_limit) {
+          $sample_rows[] = $assoc;
+        }
+        $actual_rows++;
+      }
+      fclose($fh_out); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose
+      wp_delete_file($assembled_path);
+      $assembled_path = $csv_cache_path;
+      $extension      = 'csv';
+      $total_rows     = $actual_rows;
+    } else {
+      $total_rows = count($decoded);
+    }
+  }
+  // Sniff a data type per column from the sample so the upload-step UI can
+  // pre-fill the data-type selectors. Pure inference; nothing is persisted yet.
+  $sniffed_types = vtables_sniff_column_types($headers, $sample_rows);
+  foreach ($columns as &$col_ref) {
+    $cname = isset($col_ref['name']) ? (string) $col_ref['name'] : '';
+    $col_ref['dataType'] = isset($sniffed_types[$cname]) ? $sniffed_types[$cname] : 'text';
+  }
+  unset($col_ref);
+  // Determine original table_type. The map doubles as a whitelist; rows
+  // imported before xls/xlsx were split carry the legacy merged value 'excel'.
+  $type_map = array('xlsx' => 'xlsx', 'xls' => 'xls', 'csv' => 'csv', 'json' => 'json');
+  $original_type = isset($type_map[$original_extension]) ? $type_map[$original_extension] : 'csv';
+  // Deduplicate title.
+  global $wpdb;
+  $vtables_table = $wpdb->prefix . 'vtables';
+  $title = vtables_generate_unique_title($wpdb, $vtables_table, $title);
+  $source = wp_json_encode(array('columns' => $columns, 'rows' => array()));
+  if ($source === false) {
+    wp_delete_file($assembled_path);
+    wp_send_json(array('code' => 500, 'error' => 'ENCODE_ERROR', 'message' => 'Failed to encode table structure.'), 500);
+  }
+  $result = $wpdb->insert( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $vtables_table,
+    array(
+      'title'      => $title,
+      'source'     => $source,
+      'table_type' => 'importing',
+      'settings'   => vtables_filter_settings_for_free(
+        vtables_seed_visible_columns(!empty($settings) ? $settings : '{}', $columns),
+        '{}'
+      ),
+      'file_size'  => $file_size,
+      'plan'       => 'free',
+    )
   );
+  vtables_maybe_send_nocache_headers($rest_response);
+  return $rest_response;
+}
+/**
+ * CREATE TABLE.
+ */
+add_action( 'rest_api_init', function () {
+  register_rest_route( 'vtables/v1', '/tables', array(
+    'methods' => 'POST',
+    'callback' => 'vtables_create_record_handler',
+    'permission_callback' => 'vtables_admin_permission_callback',
+  ) );
+} );
+function vtables_create_record_handler( WP_REST_Request $data ) {
+  if ($result === false) {
+    wp_delete_file($assembled_path);
+    wp_send_json(array('code' => 500, 'error' => 'DB_ERROR', 'message' => 'Failed to create table record.'), 500);
+  }
+  $table_id = $wpdb->insert_id;
+  set_transient(
+    'vtables_import_' . $table_id,
+    array(
+      'session_id'     => $session_id,
+      'file_path'      => $assembled_path,
+      'file_ext'       => $extension,
+      'total_rows'     => $total_rows,
+      'imported_rows'  => 0,
+      'original_type'  => $original_type_override ?: $original_type,
+      'headers'        => $headers,
+      // vTables Pro holds the import here until the user picks indexed
+      // columns for server-side sort/filter; there is no such step here.
+      'config_pending' => false,
+      'index_map'      => array(),
+    ),
+    DAY_IN_SECONDS
+  );
+  wp_send_json(array(
+    'table_id'       => $table_id,
+    'title'          => $title,
+    'total_rows'     => $total_rows,
+    'columns'        => $columns,
+    'config_pending' => false,
+  ));
+}
+/**
+ * IMPORT ROWS BATCH.
+ * Reads a batch of rows from the assembled file and appends them to the DB.
+ */
+add_action('wp_ajax_vtables_import_rows_batch', 'vtables_import_rows_batch_handler');
+function vtables_import_rows_batch_handler() {
+  vtables_require_admin_ajax();
+  $table_id = isset($_POST['table_id']) ? intval($_POST['table_id']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  if (!$table_id) {
+    wp_send_json(array('code' => 400, 'error' => 'MISSING_REQUIRED_FIELDS', 'message' => 'Missing table_id.'), 400);
+  }
+  $transient = get_transient('vtables_import_' . $table_id);
+  if (!$transient) {
+    wp_send_json(array('code' => 404, 'error' => 'IMPORT_NOT_FOUND', 'message' => 'Import session not found or expired.'), 404);
+  }
+  // Hold off until the upload-step index/type config is persisted (or skipped).
+  // The poller can call this immediately after finalize; returning early keeps
+  // it harmless and lets the user pick indexed columns before rows are written.
+  if (!empty($transient['config_pending'])) {
+    wp_send_json(array(
+      'imported_rows'  => intval($transient['imported_rows']),
+      'total_rows'     => intval($transient['total_rows']),
+      'done'           => false,
+      'config_pending' => true,
+    ));
+  }
+  $file_path     = $transient['file_path'];
+  $file_ext      = $transient['file_ext'];
+  $total_rows    = intval($transient['total_rows']);
+  $imported_rows = intval($transient['imported_rows']);
+  $original_type = $transient['original_type'];
+  $headers       = isset($transient['headers']) ? $transient['headers'] : array();
+  // Resolved column -> {type, slot} map (from persist_index_config). Empty = no
+  // indexed columns; slot sub-columns stay NULL for this table.
+  $index_map     = isset($transient['index_map']) && is_array($transient['index_map']) ? $transient['index_map'] : array();
+  // Guard: headers must be present in the transient.
+  if (empty($headers)) {
+    wp_send_json(array('code' => 500, 'error' => 'MISSING_HEADERS', 'message' => 'Import metadata is incomplete. Please restart the import.'), 500);
+  }
+  $batch_size = 500;
   global $wpdb;
+  $table_name = $wpdb->prefix . 'vtables';
+  $title = $data['title'];
+  $source = json_encode($data['source']);
+  $file_size = $data['file_size'];
+  $external_source = $data['external_source'];
+  $settings = json_encode($data['settings']);
+  $table_type = $data['table_type'];
+  $woocommerce_categories = json_encode($data['woocommerce_categories']);
+  if ($title) {
+    $query = $wpdb->prepare(
+      "SELECT * FROM $table_name WHERE title = %s",
+      addslashes($title)
+  $vtables_table = $wpdb->prefix . 'vtables';
+  $source_table  = $wpdb->prefix . 'vtables_source';
+  $batch_rows = array();
+  if ($file_ext === 'xlsx') {
+    $xlsx = \Shuchkin\SimpleXLSX::parse($file_path);
+    if (!$xlsx) {
+      wp_send_json(array('code' => 500, 'error' => 'PARSE_ERROR', 'message' => 'Failed to parse .xlsx file.'), 500);
+    }
+    $all_rows = $xlsx->rows();
+    array_shift($all_rows); // remove header row
+    $slice = array_slice($all_rows, $imported_rows, $batch_size);
+    foreach ($slice as $raw_row) {
+      $non_empty = array_filter($raw_row, function($v) { return $v !== '' && $v !== null; });
+      if (empty($non_empty)) continue;
+      $row_data = array();
+      foreach ($headers as $idx => $header) {
+        $row_data[$header] = isset($raw_row[$idx]) ? $raw_row[$idx] : '';
+      }
+      $batch_rows[] = $row_data;
+    }
+  } elseif ($file_ext === 'xls') {
+    $xls = \Shuchkin\SimpleXLS::parse($file_path);
+    if (!$xls) {
+      wp_send_json(array('code' => 500, 'error' => 'PARSE_ERROR', 'message' => 'Failed to parse .xls file.'), 500);
+    }
+    $all_rows = $xls->rows();
+    array_shift($all_rows);
+    $slice = array_slice($all_rows, $imported_rows, $batch_size);
+    foreach ($slice as $raw_row) {
+      $non_empty = array_filter($raw_row, function($v) { return $v !== '' && $v !== null; });
+      if (empty($non_empty)) continue;
+      $row_data = array();
+      foreach ($headers as $idx => $header) {
+        $row_data[$header] = isset($raw_row[$idx]) ? $raw_row[$idx] : '';
+      }
+      $batch_rows[] = $row_data;
+    }
+  } elseif ($file_ext === 'csv') {
+    $fh = fopen($file_path, 'r'); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen
+    if (!$fh) {
+      wp_send_json(array('code' => 500, 'error' => 'PARSE_ERROR', 'message' => 'Could not open CSV file.'), 500);
+    }
+    fgetcsv($fh); // skip header
+    $current_line = 0;
+    while (($csv_row = fgetcsv($fh)) !== false) {
+      if ($current_line < $imported_rows) {
+        $current_line++;
+        continue;
+      }
+      if ($current_line >= $imported_rows + $batch_size) {
+        break;
+      }
+      $non_empty = array_filter($csv_row, function($v) { return $v !== '' && $v !== null; });
+      if (!empty($non_empty)) {
+        $row_data = array();
+        foreach ($headers as $idx => $header) {
+          $row_data[$header] = isset($csv_row[$idx]) ? $csv_row[$idx] : '';
+        }
+        $batch_rows[] = $row_data;
+      }
+      $current_line++;
+    }
+    fclose($fh); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose
+  } elseif ($file_ext === 'json') {
+    $raw_content = file_get_contents($file_path); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_get_contents_file_get_contents
+    $decoded     = json_decode($raw_content, true);
+    if (!is_array($decoded)) {
+      wp_send_json(array('code' => 500, 'error' => 'PARSE_ERROR', 'message' => 'Could not parse JSON file.'), 500);
+    }
+    $slice = array_slice($decoded, $imported_rows, $batch_size);
+    foreach ($slice as $item) {
+      if (!is_array($item)) continue;
+      $row_data = array();
+      foreach ($headers as $header) {
+        $row_data[$header] = isset($item[$header]) ? $item[$header] : '';
+      }
+      $batch_rows[] = $row_data;
+    }
+  }
+  // Insert each row of the batch as its own record in wp_vtables_source. Each
+  // INSERT packet only carries this batch (~500 small rows) and the largest single
+  // value the server handles is one row — never the full accumulated dataset — so
+  // the max_allowed_packet ceiling that broke the old CONCAT-into-one-cell approach
+  // no longer applies. row_index stays contiguous per table_id. The 10 typed slot
+  // sub-columns are populated from the resolved index map so indexed columns get
+  // fast index-backed sort/filter (NULL when unset / uncoercible). See Phase C/D.
+  $slot_cols = vtables_slot_columns();
+  $col_list  = array_merge(array('table_id', 'row_index', 'row_json', 'search_blob'), $slot_cols);
+  $values = array();
+  $params = array();
+  $i      = 0;
+  foreach (array_values($batch_rows) as $row) {
+    $row_json = wp_json_encode($row);
+    if ($row_json === false) {
+      continue;
+    }
+    $slot_values = vtables_row_index_values($row, $index_map);
+    $placeholders = array('%d', '%d', '%s', '%s');
+    $params[] = $table_id;
+    $params[] = $imported_rows + $i;
+    $params[] = $row_json;
+    $params[] = vtables_row_search_blob($row);
+    foreach ($slot_cols as $slot_col) {
+      if (!isset($slot_values[$slot_col]) || $slot_values[$slot_col] === null) {
+        $placeholders[] = 'NULL';
+      } else {
+        $placeholders[] = '%s';
+        $params[] = $slot_values[$slot_col];
+      }
+    }
+    $values[] = '(' . implode(', ', $placeholders) . ')';
+    $i++;
+  }
+  $batch_count  = count($values);
+  $new_imported = $imported_rows + $batch_count;
+  $done         = $new_imported >= $total_rows;
+  if ($batch_count > 0) {
+    $sql = "INSERT INTO {$source_table} (" . implode(', ', $col_list) . ") VALUES " . implode(', ', $values);
+    $wpdb->query( $wpdb->prepare($sql, $params) ); // phpcs:ignore WordPress.DB.DirectDatabaseQuery, WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- $sql holds only fixed column names and placeholders; every value goes through prepare()
+    if ($wpdb->last_error) {
+      vtables_send_db_error();
+    }
+  }
+  // Flip table_type (importing -> original) when done; always bump updated_at.
+  // source stays {columns:[...], rows:[]} on wp_vtables; rows live in wp_vtables_source.
+  $wpdb->update( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $vtables_table,
+    array('table_type' => $done ? $original_type : 'importing', 'updated_at' => current_time('mysql')),
+    array('id' => $table_id),
+    array('%s', '%s'),
+    array('%d')
+  );
+  if ($done) {
+    wp_delete_file($file_path);
+    delete_transient('vtables_import_' . $table_id);
+  } else {
+    $transient['imported_rows'] = $new_imported;
+    set_transient('vtables_import_' . $table_id, $transient, DAY_IN_SECONDS);
+  }
+  wp_send_json(array(
+    'imported_rows' => $new_imported,
+    'total_rows'    => $total_rows,
+    'done'          => $done,
+  ));
+}
+/**
+ * CANCEL IMPORT.
+ * Deletes the in-progress table, the assembled file, and the import transient.
+ */
+add_action('wp_ajax_vtables_cancel_import', 'vtables_cancel_import_handler');
+function vtables_cancel_import_handler() {
+  vtables_require_admin_ajax();
+  $table_id = isset($_POST['table_id']) ? intval($_POST['table_id']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  if (!$table_id) {
+    wp_send_json(array('code' => 400, 'error' => 'MISSING_REQUIRED_FIELDS', 'message' => 'Missing table_id.'), 400);
+  }
+  // Only an import in progress can be cancelled; finished tables go through
+  // delete_table.
+  $meta = vtables_table_meta($table_id);
+  if (!$meta || $meta->table_type !== 'importing') {
+    wp_send_json(array('code' => 409, 'error' => 'NOT_IMPORTING', 'message' => 'This table is not being imported.'), 409);
+  }
+  $transient = get_transient('vtables_import_' . $table_id);
+  if ($transient) {
+    // Remove assembled file.
+    if (!empty($transient['file_path']) && file_exists($transient['file_path'])) {
+      wp_delete_file($transient['file_path']);
+    }
+    // Remove chunk dir if still present (upload was cancelled before finalize).
+    if (!empty($transient['session_id']) && preg_match('/^[0-9a-f\-]{36}$/i', $transient['session_id'])) {
+      $chunk_dir = vtables_uploads_dir() . 'chunks/' . $transient['session_id'] . '/';
+      if (is_dir($chunk_dir)) {
+        vtables_remove_directory($chunk_dir);
+      }
+    }
+    delete_transient('vtables_import_' . $table_id);
+  }
+  global $wpdb;
+  $vtables_table = $wpdb->prefix . 'vtables';
+  $wpdb->delete($vtables_table, array('id' => $table_id), array('%d')); // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+  $wpdb->delete($wpdb->prefix . 'vtables_source', array('table_id' => $table_id), array('%d')); // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+  wp_send_json(array('success' => true));
+}
+/**
+ * CANCEL CHUNK UPLOAD.
+ * Removes the chunk directory for an in-progress (pre-finalize) upload session.
+ */
+add_action('wp_ajax_vtables_cancel_chunk_upload', 'vtables_cancel_chunk_upload_handler');
+function vtables_cancel_chunk_upload_handler() {
+  vtables_require_admin_ajax();
+  $session_id = isset($_POST['session_id']) ? sanitize_text_field(wp_unslash($_POST['session_id'])) : ''; // phpcs:ignore WordPress.Security.NonceVerification
+  if (!preg_match('/^[0-9a-f\-]{36}$/i', $session_id)) {
+    wp_send_json(array('code' => 400, 'error' => 'INVALID_PARAMS', 'message' => 'Invalid session ID.'), 400);
+  }
+  $chunk_dir = vtables_uploads_dir() . 'chunks/' . $session_id . '/';
+  if (is_dir($chunk_dir)) {
+    vtables_remove_directory($chunk_dir);
+  }
+  wp_send_json(array('success' => true));
+}
+/**
+ * QUERY ROWS (server-mode paginated read).
+ */
+add_action('wp_ajax_vtables_query_rows', 'vtables_query_rows_handler');
+add_action('wp_ajax_nopriv_vtables_query_rows', 'vtables_query_rows_handler');
+function vtables_query_rows_handler() {
+  if (!defined('DOING_AJAX') || !DOING_AJAX) {
+    wp_send_json(array('code' => 400, 'error' => 'INVALID_REQUEST', 'message' => 'Invalid request.'), 400);
+  }
+  $table_id = isset($_GET['table_id']) ? intval($_GET['table_id']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  if (!$table_id) {
+    wp_send_json(array('code' => 400, 'error' => 'MISSING_REQUIRED_FIELDS', 'message' => 'Missing table_id.'), 400);
+  }
+  vtables_reject_pro_table($table_id);
+  // Plain pagination only: search, sorting and filtering are vTables Pro features.
+  $result = vtables_query_source_rows(array(
+    'table_id'        => $table_id,
+    'page'            => isset($_GET['page']) ? intval($_GET['page']) : 1, // phpcs:ignore WordPress.Security.NonceVerification
+    'per_page'        => isset($_GET['per_page']) ? intval($_GET['per_page']) : vtables_default_per_page(), // phpcs:ignore WordPress.Security.NonceVerification
+    'after_row_index' => isset($_GET['after_row_index']) && $_GET['after_row_index'] !== '' ? intval($_GET['after_row_index']) : '', // phpcs:ignore WordPress.Security.NonceVerification
+  ));
+  global $wpdb;
+  if ($wpdb->last_error) {
+    vtables_send_db_error();
+  }
+  wp_send_json(array('rows' => $result['rows'], 'total' => $result['total']));
+}
+/**
+ * UPDATE ROW (server-mode single-row edit).
+ */
+add_action('wp_ajax_vtables_update_row', 'vtables_update_row_handler');
+function vtables_update_row_handler() {
+  vtables_require_admin_ajax();
+  $table_id = isset($_POST['table_id']) ? intval($_POST['table_id']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  $vt_id    = isset($_POST['vt_id']) ? intval($_POST['vt_id']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  $row_raw  = isset($_POST['row']) ? wp_unslash($_POST['row']) : ''; // phpcs:ignore WordPress.Security.NonceVerification, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- JSON, decoded below
+  if (!$table_id || !$vt_id) {
+    wp_send_json(array('code' => 400, 'error' => 'MISSING_REQUIRED_FIELDS', 'message' => 'Missing table_id or vt_id.'), 400);
+  }
+  vtables_reject_pro_table($table_id);
+  $row = json_decode($row_raw, true);
+  if (!is_array($row)) {
+    wp_send_json(array('code' => 400, 'error' => 'INVALID_ROW', 'message' => 'Invalid row payload.'), 400);
+  }
+  unset($row['vt_id'], $row['vt_row_index']);
+  global $wpdb;
+  $source_table = $wpdb->prefix . 'vtables_source';
+  $row_json = wp_json_encode($row);
+  // Refresh search_blob AND the typed slot sub-columns so search and indexed
+  // sort/filter stay consistent with the edited cell values.
+  $index_map   = vtables_table_index_map($table_id);
+  $slot_values = vtables_row_index_values($row, $index_map);
+  $data    = array('row_json' => $row_json, 'search_blob' => vtables_row_search_blob($row));
+  $formats = array('%s', '%s');
+  foreach (vtables_slot_columns() as $slot_col) {
+    $data[$slot_col]  = isset($slot_values[$slot_col]) ? $slot_values[$slot_col] : null;
+    $formats[]        = '%s';
+  }
+  $result = $wpdb->update( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $source_table,
+    $data,
+    array('id' => $vt_id, 'table_id' => $table_id),
+    $formats,
+    array('%d', '%d')
+  );
+  if ($result === false) {
+    wp_send_json(array('code' => 500, 'error' => 'DB_ERROR', 'message' => 'Failed to update row.'), 500);
+  }
+  // Cell values changed but the row count didn't; only filtered/searched totals
+  // could shift, so drop the cached counts for this table to stay correct.
+  vtables_invalidate_count_cache($table_id);
+  wp_send_json(array('vt_id' => $vt_id));
+}
+/**
+ * INSERT ROW (server-mode add row).
+ */
+/**
+ * Named-lock key serializing anchored inserts per table. GET_LOCK names are
+ * global to the MySQL server and capped at 64 chars, so scope per
+ * install+blog+table through a hash. The same name vTables Pro uses, since
+ * both write rows of the same tables.
+ */
+function vtables_row_insert_lock_name($table_id) {
+  global $wpdb;
+  $db = defined('DB_NAME') ? DB_NAME : '';
+  return 'vtables_pro_rows:' . md5($db . '|' . $wpdb->prefix . '|' . (int) $table_id);
+}
+add_action('wp_ajax_vtables_insert_row', 'vtables_insert_row_handler');
+function vtables_insert_row_handler() {
+  vtables_require_admin_ajax();
+  $table_id     = isset($_POST['table_id']) ? intval($_POST['table_id']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  $after_index  = isset($_POST['after_index']) ? intval($_POST['after_index']) : -1; // phpcs:ignore WordPress.Security.NonceVerification
+  $anchor_vt_id = isset($_POST['anchor_vt_id']) ? intval($_POST['anchor_vt_id']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  $position     = isset($_POST['position']) && sanitize_text_field(wp_unslash($_POST['position'])) === 'before' ? 'before' : 'after'; // phpcs:ignore WordPress.Security.NonceVerification
+  $row_raw      = isset($_POST['row']) ? wp_unslash($_POST['row']) : ''; // phpcs:ignore WordPress.Security.NonceVerification, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- JSON, decoded below
+  if (!$table_id) {
+    wp_send_json(array('code' => 400, 'error' => 'MISSING_REQUIRED_FIELDS', 'message' => 'Missing table_id.'), 400);
+  }
+  // Bail before any write: wp_vtables_source has no FK, so an insert against a
+  // deleted/never-existing table_id would orphan the row permanently.
+  if (!vtables_table_exists($table_id)) {
+    wp_send_json(array('code' => 404, 'error' => 'TABLE_NOT_FOUND', 'message' => 'Table not found.'), 404);
+  }
+  vtables_reject_pro_table($table_id);
+  $row = json_decode($row_raw, true);
+  if (!is_array($row)) {
+    $row = array();
+  }
+  unset($row['vt_id'], $row['vt_row_index']);
+  global $wpdb;
+  $source_table = $wpdb->prefix . 'vtables_source';
+  // Anchored insert: resolve the target index from the anchor row, shift every
+  // row at/after it up by one and take the freed slot. Keeps row_index unique
+  // and ordered — keyset pagination in vtables_query_source_rows
+  // (WHERE row_index > %d) breaks on duplicates, which is why the old sparse
+  // "after_index + 1" placement misplaced rows. The shift and the insert are
+  // two statements, so serialize per table with a named lock (session-scoped,
+  // released on request shutdown, so every wp_send_json exit path is covered).
+  if ($anchor_vt_id > 0) {
+    $lock = vtables_row_insert_lock_name($table_id);
+    $acquired = (int) $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+      $wpdb->prepare('SELECT GET_LOCK(%s, %d)', $lock, 10)
     );
+    $row_exists = $wpdb->get_results($query);
+    $title = $row_exists ? $title . '-copy' : $title;
+  }
+  $results = $wpdb->insert($table_name,
+    array(
+      'title' => $title,
+      'source' => $source,
+      'file_size' => $file_size,
+      'external_source' => $external_source,
+      'settings' => $settings,
+      'table_type' => $table_type,
+      'woocommerce_categories' => $woocommerce_categories,
+    )
+    if ($acquired !== 1) {
+      wp_send_json(array('code' => 503, 'error' => 'ROWS_BUSY', 'message' => 'Another row operation is in progress. Please retry.'), 503);
+    }
+    register_shutdown_function(function () use ($wpdb, $lock) {
+      $wpdb->query($wpdb->prepare('SELECT RELEASE_LOCK(%s)', $lock)); // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    });
+    $anchor_index = $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+      $wpdb->prepare( "SELECT row_index FROM {$wpdb->prefix}vtables_source WHERE id = %d AND table_id = %d", $anchor_vt_id, $table_id )
+    );
+    if ($anchor_index === null) {
+      wp_send_json(array('code' => 404, 'error' => 'ANCHOR_NOT_FOUND', 'message' => 'Anchor row not found.'), 404);
+    }
+    $new_index = (int) $anchor_index + ($position === 'after' ? 1 : 0);
+    $shifted = $wpdb->query( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+      $wpdb->prepare( "UPDATE {$wpdb->prefix}vtables_source SET row_index = row_index + 1 WHERE table_id = %d AND row_index >= %d", $table_id, $new_index )
+    );
+    if ($shifted === false) {
+      wp_send_json(array('code' => 500, 'error' => 'DB_ERROR', 'message' => 'Failed to insert row.'), 500);
+    }
+  } elseif ($after_index >= 0) {
+    // Legacy sparse positioning (no anchor supplied): place just after the
+    // requested index; ORDER BY row_index, id breaks the tie.
+    $new_index = $after_index + 1;
+  } else {
+    $max_index = $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+      $wpdb->prepare( "SELECT MAX(row_index) FROM {$wpdb->prefix}vtables_source WHERE table_id = %d", $table_id )
+    );
+    $new_index = ($max_index === null) ? 0 : ((int) $max_index + 1);
+  }
+  // Populate the typed slot sub-columns for indexed columns on insert too.
+  $index_map   = vtables_table_index_map($table_id);
+  $slot_values = vtables_row_index_values($row, $index_map);
+  $data = array(
+    'table_id'    => $table_id,
+    'row_index'   => $new_index,
+    'row_json'    => wp_json_encode($row),
+    'search_blob' => vtables_row_search_blob($row),
   );
+  $response = array();
+  $response['id'] = $wpdb->insert_id;
+  $rest_response = new WP_REST_Response(
+    array(
+      'success' => !!$results,
+      'data' => $response,
+    )
+  $formats = array('%d', '%d', '%s', '%s');
+  foreach (vtables_slot_columns() as $slot_col) {
+    $data[$slot_col] = isset($slot_values[$slot_col]) ? $slot_values[$slot_col] : null;
+    $formats[]       = '%s';
+  }
+  $result = $wpdb->insert($source_table, $data, $formats); // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+  if ($result === false) {
+    wp_send_json(array('code' => 500, 'error' => 'DB_ERROR', 'message' => 'Failed to insert row.'), 500);
+  }
+  vtables_invalidate_count_cache($table_id);
+  wp_send_json(array('vt_id' => $wpdb->insert_id, 'row_index' => $new_index));
+}
+/**
+ * DELETE ROW (server-mode delete row).
+ */
+add_action('wp_ajax_vtables_delete_row', 'vtables_delete_row_handler');
+function vtables_delete_row_handler() {
+  vtables_require_admin_ajax();
+  $table_id = isset($_POST['table_id']) ? intval($_POST['table_id']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  $vt_id    = isset($_POST['vt_id']) ? intval($_POST['vt_id']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  if (!$table_id || !$vt_id) {
+    wp_send_json(array('code' => 400, 'error' => 'MISSING_REQUIRED_FIELDS', 'message' => 'Missing table_id or vt_id.'), 400);
+  }
+  vtables_reject_pro_table($table_id);
+  global $wpdb;
+  $source_table = $wpdb->prefix . 'vtables_source';
+  $result = $wpdb->delete( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $source_table,
+    array('id' => $vt_id, 'table_id' => $table_id),
+    array('%d', '%d')
   );
+  vtables_maybe_send_nocache_headers($rest_response);
+  return $rest_response;
+}
+/**
+ * SAVE TABLE CHANGES.
+ */
+add_action( 'rest_api_init', function () {
+  register_rest_route( 'vtables/v1', '/source', array(
+    'methods' => 'PUT',
+    'callback' => 'vtables_save_table_changes_handler',
+    'permission_callback' => 'vtables_admin_permission_callback',
+  ) );
+} );
+function vtables_save_table_changes_handler( WP_REST_Request $data ) {
+  if ($result === false) {
+    wp_send_json(array('code' => 500, 'error' => 'DB_ERROR', 'message' => 'Failed to delete row.'), 500);
+  }
+  vtables_invalidate_count_cache($table_id);
+  wp_send_json(array('vt_id' => $vt_id));
+}
+/**
+ * HELPER: the table's stored columns as name/label pairs.
+ * Names key row_json; export needs the labels too, because that is what the
+ * UI shows as the header.
+ */
+if (!function_exists('vtables_table_column_pairs')) {
+  function vtables_table_column_pairs($table_id) {
+    global $wpdb;
+    $source = $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+      $wpdb->prepare( "SELECT source FROM {$wpdb->prefix}vtables WHERE id = %d", $table_id )
+    );
+    $decoded = json_decode($source, true);
+    $pairs = array();
+    if (is_array($decoded) && isset($decoded['columns']) && is_array($decoded['columns'])) {
+      foreach ($decoded['columns'] as $col) {
+        if (!isset($col['name'])) {
+          continue;
+        }
+        $name = (string) $col['name'];
+        $pairs[] = array(
+          'name'  => $name,
+          'label' => isset($col['label']) && $col['label'] !== '' ? (string) $col['label'] : $name,
+        );
+      }
+    }
+    return $pairs;
+  }
+}
+/**
+ * HELPER: flatten one cell value for a CSV field.
+ * Cells are not always scalars — json-typed cells hold objects/arrays and
+ * booleans. Handing those to fputcsv() emits the literal "Array" plus a PHP
+ * notice, so encode them instead.
+ */
+if (!function_exists('vtables_export_scalarize')) {
+  function vtables_export_scalarize($value) {
+    if (is_null($value)) {
+      return '';
+    }
+    if (is_bool($value)) {
+      return $value ? 'true' : 'false';
+    }
+    if (is_scalar($value)) {
+      return (string) $value;
+    }
+    return (string) wp_json_encode($value);
+  }
+}
+/**
+ * Hard ceiling of the xlsx sheet format itself (rows per worksheet).
+ */
+if (!defined('VTABLES_XLSX_MAX_ROWS')) {
+  define('VTABLES_XLSX_MAX_ROWS', 1048576);
+}
+/**
+ * EXPORT ROWS (stream all rows for a table without buffering the whole dataset).
+ *
+ * Always exports the full, unfiltered table — the active search/filter/sort of
+ * the browsing session is deliberately not applied.
+ */
+add_action('wp_ajax_vtables_export_rows', 'vtables_export_rows_handler');
+function vtables_export_rows_handler() {
+  vtables_require_admin_ajax();
+  $table_id = isset($_GET['table_id']) ? intval($_GET['table_id']) : 0; // phpcs:ignore WordPress.Security.NonceVerification
+  $format   = isset($_GET['format']) ? sanitize_text_field(wp_unslash($_GET['format'])) : 'csv'; // phpcs:ignore WordPress.Security.NonceVerification
+  if (!in_array($format, array('csv', 'json', 'xlsx'), true)) {
+    $format = 'csv';
+  }
+  if (!$table_id) {
+    wp_send_json(array('code' => 400, 'error' => 'MISSING_REQUIRED_FIELDS', 'message' => 'Missing table_id.'), 400);
+  }
   global $wpdb;
+  $table_name = $wpdb->prefix . 'vtables';
+  $id = $data['id'];
+  $title = $data['title'];
+  $source = $data['source'];
+  $file_size = $data['fileSize'];
+  $sourceJSON = json_encode($data['source']);
+  // Update only title
+  if ($title && empty($source)) {
+    $results = $wpdb->update(
+      $table_name,
+      array(
+        'title' => $title,
+        'updated_at' => date('Y-m-d h:i:s'),
+      ),
+      array( 'id' => $data['id'] ),
+  $table = $wpdb->get_row( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $wpdb->prepare( "SELECT id, title, table_type, source FROM {$wpdb->prefix}vtables WHERE id = %d", $table_id )
+  );
+  if (!$table) {
+    wp_send_json(array('code' => 404, 'error' => 'NOT_FOUND', 'message' => 'Table not found.'), 404);
+  }
+  vtables_reject_pro_table($table_id);
+  // Everything that can refuse the request has to do so before a byte of the
+  // download goes out, so the xlsx preconditions are checked up here.
+  if ($format === 'xlsx') {
+    if (!class_exists('ZipArchive')) {
+      wp_send_json(array('code' => 501, 'error' => 'ZIP_UNAVAILABLE', 'message' => 'XLSX export needs the PHP zip extension. Use CSV instead.'), 501);
+    }
+    $row_count = (int) $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+      $wpdb->prepare( "SELECT COUNT(*) FROM {$wpdb->prefix}vtables_source WHERE table_id = %d", $table_id )
     );
+    return new WP_REST_Response(
+      array(
+        'success' => !!$results,
+        'data' => $results,
+      )
+    // The sheet format itself caps out at 1,048,576 rows (one goes to the
+    // header). Truncating silently would hand back a plausible-looking but
+    // incomplete file, so refuse and point at the formats that have no ceiling.
+    if ($row_count > VTABLES_XLSX_MAX_ROWS - 1) {
+      wp_send_json(array(
+        'code'    => 400,
+        'error'   => 'TOO_MANY_ROWS',
+        'message' => sprintf('This table has %d rows; XLSX holds at most %d. Export as CSV or JSON instead.', $row_count, VTABLES_XLSX_MAX_ROWS - 1),
+      ), 400);
+    }
+  }
+  // Match the filename the client-side exporter used before this endpoint
+  // existed, so downloads stay recognizable.
+  $basename = sanitize_file_name($table->title);
+  if ($basename === '') {
+    $basename = 'vtable-' . $table_id;
+  }
+  // Streaming past a buffer would defeat the whole point (and blow memory on
+  // large tables), so drop whatever WordPress/plugins have open.
+  while (ob_get_level() > 0) {
+    ob_end_clean();
+  }
+  $content_types = array(
+    'json' => 'application/json; charset=utf-8',
+    'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'csv'  => 'text/csv; charset=utf-8',
+  );
+  nocache_headers();
+  header('Content-Type: ' . $content_types[$format]);
+  header('Content-Disposition: attachment; filename="' . $basename . '.' . $format . '"');
+  $writer = vtables_export_writer_open($format);
+  vtables_export_stream_source_rows($table, $writer);
+  vtables_export_writer_close($writer);
+  wp_die();
+}
+/**
+ * EXPORT: stream rows out of wp_vtables_source.
+ * Legacy tables kept their rows inside the source blob and have no records
+ * there, so fall back to that blob rather than emitting an empty file.
+ */
+function vtables_export_stream_source_rows($table, &$writer) {
+  global $wpdb;
+  $table_id     = (int) $table->id;
+  $pairs        = vtables_table_column_pairs($table_id);
+  $has_records = (int) $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    $wpdb->prepare( "SELECT COUNT(*) FROM {$wpdb->prefix}vtables_source WHERE table_id = %d", $table_id )
+  ) > 0;
+  $legacy_rows = array();
+  if (!$has_records) {
+    $decoded = json_decode($table->source, true);
+    if (is_array($decoded) && isset($decoded['rows']) && is_array($decoded['rows'])) {
+      $legacy_rows = $decoded['rows'];
+    }
+  }
+  vtables_export_writer_header($writer, $pairs);
+  $batch  = 1000;
+  $offset = 0;
+  do {
+    if ($has_records) {
+      $records = $wpdb->get_col( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+        $wpdb->prepare( "SELECT row_json FROM {$wpdb->prefix}vtables_source WHERE table_id = %d ORDER BY row_index ASC, id ASC LIMIT %d OFFSET %d", $table_id, $batch, $offset )
+      );
+    } else {
+      $records = array_map('wp_json_encode', array_slice($legacy_rows, $offset, $batch));
+    }
+    foreach ($records as $row_json) {
+      if ($writer['format'] === 'json') {
+        // Already-encoded JSON goes out verbatim — no decode/re-encode round trip.
+        vtables_export_writer_row($writer, null, $pairs, $row_json);
+        continue;
+      }
+      $row = json_decode($row_json, true);
+      if (!is_array($row)) {
+        continue;
+      }
+      vtables_export_writer_row($writer, $row, $pairs);
+    }
+    $offset += $batch;
+    flush();
+  } while (count($records) === $batch);
+}
+/**
+ * EXPORT: one row -> the values for the column list, in column order. Without
+ * a column list (columnless legacy sources) fall back to the row's own order.
+ */
+function vtables_export_row_values($row, $pairs) {
+  if (empty($pairs)) {
+    return array_values($row);
+  }
+  $values = array();
+  foreach ($pairs as $pair) {
+    $values[] = isset($row[$pair['name']]) ? $row[$pair['name']] : '';
+  }
+  return $values;
+}
+/**
+ * ============================================================================
+ * EXPORT WRITERS
+ * One tiny state machine per output format, so the two row-producing streams
+ * above stay format-agnostic. csv and json go straight to php://output; xlsx
+ * builds on disk (see vtables_export_writer_close).
+ * ============================================================================
+ */
+function vtables_export_writer_open($format) {
+  $writer = array('format' => $format);
+  if ($format === 'json') {
+    $writer['first'] = true;
+    echo '[';
+    return $writer;
+  }
+  if ($format === 'csv') {
+    $writer['out'] = fopen('php://output', 'w'); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen
+    return $writer;
+  }
+  // xlsx: the sheet is the only large part, so it is written to a temp file as
+  // rows arrive and zipped at the end — memory stays flat regardless of size.
+  $writer['sheet_path'] = wp_tempnam('vtables-export-sheet');
+  $writer['sheet']      = fopen($writer['sheet_path'], 'w'); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen
+  $writer['row']        = 0;
+  fwrite( // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite
+    $writer['sheet'],
+    '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+    . '<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"><sheetData>'
+  );
+  return $writer;
+}
+function vtables_export_writer_header(&$writer, $pairs) {
+  if ($writer['format'] === 'json' || empty($pairs)) {
+    return;
+  }
+  $labels = wp_list_pluck($pairs, 'label');
+  if ($writer['format'] === 'csv') {
+    fputcsv($writer['out'], $labels); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite
+    return;
+  }
+  vtables_export_xlsx_row($writer, $labels);
+}
+/**
+ * @param array|null  $row     decoded row; may be null when $encoded is given.
+ * @param array       $pairs   column list.
+ * @param string|null $encoded pre-encoded JSON, to skip a decode/encode cycle.
+ */
+function vtables_export_writer_row(&$writer, $row, $pairs, $encoded = null) {
+  if ($writer['format'] === 'json') {
+    echo $writer['first'] ? '' : ','; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped
+    echo $encoded !== null ? $encoded : wp_json_encode($row); // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped
+    $writer['first'] = false;
+    return;
+  }
+  $values = vtables_export_row_values($row, $pairs);
+  if ($writer['format'] === 'csv') {
+    fputcsv($writer['out'], array_map('vtables_export_scalarize', $values)); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite
+    return;
+  }
+  vtables_export_xlsx_row($writer, $values);
+}
+function vtables_export_writer_close(&$writer) {
+  if ($writer['format'] === 'json') {
+    echo ']';
+    return;
+  }
+  if ($writer['format'] === 'csv') {
+    fclose($writer['out']); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose
+    return;
+  }
+  fwrite($writer['sheet'], '</sheetData></worksheet>'); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite
+  fclose($writer['sheet']); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose
+  $xlsx_path = wp_tempnam('vtables-export-book');
+  $zip = new ZipArchive();
+  if ($zip->open($xlsx_path, ZipArchive::OVERWRITE) === true) {
+    foreach (vtables_export_xlsx_parts() as $name => $contents) {
+      $zip->addFromString($name, $contents);
+    }
+    $zip->addFile($writer['sheet_path'], 'xl/worksheets/sheet1.xml');
+    $zip->close();
+    readfile($xlsx_path); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_readfile
+  }
+  wp_delete_file($writer['sheet_path']);
+  wp_delete_file($xlsx_path);
+}
+/**
+ * XLSX: append one <row>. Values that are genuinely numeric become numeric
+ * cells; everything else becomes an inline string — which is what lets the
+ * sheet stream, since a shared-strings table would have to be held in memory
+ * until the very last row.
+ */
+function vtables_export_xlsx_row(&$writer, $values) {
+  $writer['row']++;
+  $r = $writer['row'];
+  $xml = '<row r="' . $r . '">';
+  $c = 0;
+  foreach ($values as $value) {
+    $c++;
+    $ref = vtables_export_xlsx_column_ref($c) . $r;
+    if (vtables_export_xlsx_is_numeric($value)) {
+      $xml .= '<c r="' . $ref . '"><v>' . (0 + $value) . '</v></c>';
+      continue;
+    }
+    $text = vtables_export_xlsx_text($value);
+    if ($text === '') {
+      continue; // an empty cell needs no element at all
+    }
+    // xml:space="preserve" or Excel eats leading/trailing whitespace.
+    $xml .= '<c r="' . $ref . '" t="inlineStr"><is><t xml:space="preserve">' . $text . '</t></is></c>';
+  }
+  $xml .= '</row>';
+  fwrite($writer['sheet'], $xml); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite
+}
+/**
+ * XLSX: should this value be written as a number?
+ * Only when the canonical numeric form round-trips — so "00601" (a zip code)
+ * and "1e5" stay text rather than being silently rewritten by the spreadsheet.
+ */
+function vtables_export_xlsx_is_numeric($value) {
+  if (is_int($value) || is_float($value)) {
+    return is_finite((float) $value);
+  }
+  if (!is_string($value) || $value === '' || !is_numeric($value)) {
+    return false;
+  }
+  return (string) (0 + $value) === $value;
+}
+/**
+ * XLSX: escape a value for XML. Control characters are not merely invalid
+ * here — Excel rejects the whole workbook over one of them, so strip them.
+ */
+function vtables_export_xlsx_text($value) {
+  $text = vtables_export_scalarize($value);
+  // Byte-wise is safe: UTF-8 continuation bytes are all >= 0x80.
+  $text = preg_replace('/[\x00-\x08\x0B\x0C\x0E-\x1F]/', '', $text);
+  return htmlspecialchars($text, ENT_QUOTES | ENT_XML1, 'UTF-8');
+}
+/**
+ * XLSX: 1 -> A, 26 -> Z, 27 -> AA, ...
+ */
+function vtables_export_xlsx_column_ref($index) {
+  $ref = '';
+  while ($index > 0) {
+    $index--;
+    $ref = chr(65 + ($index % 26)) . $ref;
+    $index = intdiv($index, 26);
+  }
+  return $ref;
+}
+/**
+ * XLSX: the fixed, tiny package parts. Everything variable lives in
+ * xl/worksheets/sheet1.xml, which is added separately from its temp file.
+ */
+function vtables_export_xlsx_parts() {
+  $ns_rel = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+  $decl   = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  return array(
+    '[Content_Types].xml' => $decl
+      . '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">'
+      . '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>'
+      . '<Default Extension="xml" ContentType="application/xml"/>'
+      . '<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>'
+      . '<Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>'
+      . '<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>'
+      . '</Types>',
+    '_rels/.rels' => $decl
+      . '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">'
+      . '<Relationship Id="rId1" Type="' . $ns_rel . '/officeDocument" Target="xl/workbook.xml"/>'
+      . '</Relationships>',
+    'xl/workbook.xml' => $decl
+      . '<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="' . $ns_rel . '">'
+      . '<sheets><sheet name="Sheet1" sheetId="1" r:id="rId1"/></sheets>'
+      . '</workbook>',
+    'xl/_rels/workbook.xml.rels' => $decl
+      . '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">'
+      . '<Relationship Id="rId1" Type="' . $ns_rel . '/worksheet" Target="worksheets/sheet1.xml"/>'
+      . '<Relationship Id="rId2" Type="' . $ns_rel . '/styles" Target="styles.xml"/>'
+      . '</Relationships>',
+    // Minimal but complete: readers that assume a styles part exists (and index
+    // style 0) would otherwise choke.
+    'xl/styles.xml' => $decl
+      . '<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">'
+      . '<fonts count="1"><font><sz val="11"/><name val="Calibri"/></font></fonts>'
+      . '<fills count="1"><fill><patternFill patternType="none"/></fill></fills>'
+      . '<borders count="1"><border/></borders>'
+      . '<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>'
+      . '<cellXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/></cellXfs>'
+      . '</styleSheet>',
+  );
+}
+/**
+ * HELPER: page size for server-mode reads.
+ * Fixed: the rows-per-page setting (settings.bottom.initial.rowsPerPage) is a
+ * vTables Pro feature, so every table pages by the same default a new table
+ * starts with (INITIAL_SETTINGS in src/stores/main/constants.ts).
+ */
+if (!function_exists('vtables_default_per_page')) {
+  function vtables_default_per_page() {
+    return max(1, min(1000, (int) apply_filters('vtables_default_per_page', 10)));
+  }
+}
+/**
+ * HELPER: hard upload size cap in bytes (10 MB). Enforced client- and server-side.
+ */
+if (!function_exists('vtables_max_upload_bytes')) {
+  function vtables_max_upload_bytes() {
+    return (int) apply_filters('vtables_max_upload_bytes', 10 * 1024 * 1024);
+  }
+}
+/**
+ * HELPER: ordered list of the typed slot sub-columns on wp_vtables_source.
+ * Slot k (1..5): idx_k_txt (VARCHAR) for text, idx_k_num (DECIMAL) for
+ * number/date(epoch)/boolean(0|1).
+ */
+if (!function_exists('vtables_slot_columns')) {
+  function vtables_slot_columns() {
+    $cols = array();
+    for ($k = 1; $k <= 5; $k++) {
+      $cols[] = "idx_{$k}_txt";
+      $cols[] = "idx_{$k}_num";
+    }
+    return $cols;
+  }
+}
+/**
+ * HELPER: coerce a raw cell value to the numeric representation for a data type,
+ * or null when it can't be represented (so it sorts last and never throws).
+ * Returns array('txt' => string|null, 'num' => string|null) — only one is used
+ * per slot depending on the column's type, but both are computed cheaply.
+ */
+if (!function_exists('vtables_coerce_index_value')) {
+  function vtables_coerce_index_value($value, $type) {
+    if (is_array($value) || is_object($value)) {
+      // Non-scalar values can't be indexed meaningfully.
+      return array('txt' => null, 'num' => null);
+    }
+    $str = ($value === null) ? '' : (string) $value;
+    $trimmed = trim($str);
+    switch ($type) {
+      case 'number':
+        if ($trimmed === '' || !is_numeric($trimmed)) {
+          return array('txt' => null, 'num' => null);
+        }
+        return array('txt' => null, 'num' => (string) (0 + $trimmed));
+      case 'date':
+        if ($trimmed === '') {
+          return array('txt' => null, 'num' => null);
+        }
+        // Numeric epoch passes straight through; otherwise parse a date string.
+        if (is_numeric($trimmed)) {
+          return array('txt' => null, 'num' => (string) (int) $trimmed);
+        }
+        $ts = strtotime($trimmed);
+        if ($ts === false) {
+          return array('txt' => null, 'num' => null);
+        }
+        return array('txt' => null, 'num' => (string) $ts);
+      case 'boolean':
+        if ($trimmed === '') {
+          return array('txt' => null, 'num' => null);
+        }
+        $low = strtolower($trimmed);
+        if (in_array($low, array('1', 'true', 'yes', 'y', 'on'), true)) {
+          return array('txt' => null, 'num' => '1');
+        }
+        if (in_array($low, array('0', 'false', 'no', 'n', 'off'), true)) {
+          return array('txt' => null, 'num' => '0');
+        }
+        return array('txt' => null, 'num' => null);
+      case 'text':
+      default:
+        if ($str === '') {
+          return array('txt' => null, 'num' => null);
+        }
+        // VARCHAR(191): truncate for indexing only (raw value stays in row_json).
+        return array('txt' => function_exists('mb_substr') ? mb_substr($str, 0, 191) : substr($str, 0, 191), 'num' => null);
+    }
+  }
+}
+/**
+ * HELPER: build the slot sub-column values for one row from a resolved index map
+ * ($map: column name -> array('type' => ..., 'slot' => 1..5)).
+ * Returns array('idx_k_txt' => ..., 'idx_k_num' => ...) with null where unused.
+ */
+if (!function_exists('vtables_row_index_values')) {
+  function vtables_row_index_values($row, $map) {
+    $out = array();
+    if (!is_array($row) || !is_array($map) || empty($map)) {
+      return $out;
+    }
+    foreach ($map as $col => $meta) {
+      $slot = isset($meta['slot']) ? (int) $meta['slot'] : 0;
+      $type = isset($meta['type']) ? (string) $meta['type'] : 'text';
+      if ($slot < 1 || $slot > 5) {
+        continue;
+      }
+      $value = isset($row[$col]) ? $row[$col] : null;
+      $coerced = vtables_coerce_index_value($value, $type);
+      if ($type === 'text') {
+        $out["idx_{$slot}_txt"] = $coerced['txt'];
+        $out["idx_{$slot}_num"] = null;
+      } else {
+        $out["idx_{$slot}_txt"] = null;
+        $out["idx_{$slot}_num"] = $coerced['num'];
+      }
+    }
+    return $out;
+  }
+}
+/**
+ * HELPER: does a table row exist in wp_vtables? Handlers that write rows into
+ * wp_vtables_source must call this first — the source table has no FK back to
+ * wp_vtables, so inserting against a stale/bogus table_id silently orphans the
+ * row where nothing but a manual sweep will find it.
+ */
+if (!function_exists('vtables_table_exists')) {
+  function vtables_table_exists($table_id) {
+    global $wpdb;
+    $found = $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+      $wpdb->prepare( "SELECT id FROM {$wpdb->prefix}vtables WHERE id = %d", $table_id )
     );
+  }
+  // Update source
+  $results = $wpdb->update(
+    $table_name,
+    array(
+      'title' => $title,
+      'file_size' => $file_size,
+      'source' => $sourceJSON,
+      'updated_at' => date('Y-m-d h:i:s'),
+    ),
+    array( 'id' => $data['id'] ),
+    array( '%s', '%d', '%s', '%s' ),
+    array( '%d' )
+  );
+  $query = $wpdb->prepare("SELECT * FROM $table_name WHERE id = %d", $id);
+  $updated_table = $wpdb->get_results($query)[0];
+  $updated_table->source = json_decode($updated_table->source);
+  $response = $updated_table;
+  $rest_response = new WP_REST_Response(
+    array(
+      'success' => !!$results,
+      'data' => $response,
+    )
+  );
+  vtables_maybe_send_nocache_headers($rest_response);
+  return $rest_response;
+}
+/**
+ * SAVE TABLE SETTINGS.
+ */
+add_action( 'rest_api_init', function () {
+  register_rest_route( 'vtables/v1', '/settings', array(
+    'methods' => 'PUT',
+    'callback' => 'vtables_save_table_settings_handler',
+    'permission_callback' => 'vtables_admin_permission_callback',
+  ) );
+} );
+function vtables_save_table_settings_handler( WP_REST_Request $data ) {
+  global $wpdb;
+  $table_name = $wpdb->prefix . 'vtables';
+  $settings = $data['settings'];
+  $settingsJSON = json_encode($data['settings']);
+  $results = $wpdb->update(
+    $table_name,
+    array(
+      'settings' => $settingsJSON,
+      'updated_at' => date('Y-m-d h:i:s'),
+    ),
+    array( 'id' => $data['id'] ),
+    array( '%s', '%s' ),
+    array( '%d' )
+  );
+  $response = array();
+  $response['success'] = true;
+  $response['updated_at'] = date('Y-m-d h:i:s');
+  $rest_response = new WP_REST_Response(
+    array(
+      'success' => !!$results,
+      'data' => $response,
+    )
+  );
+  vtables_maybe_send_nocache_headers($rest_response);
+  return $rest_response;
+}
+/**
+ * DELETE TABLE.
+ */
+add_action( 'rest_api_init', function () {
+  register_rest_route( 'vtables/v1', '/tables', array(
+    'methods' => 'DELETE',
+    'callback' => 'vtables_delete_record_handler',
+    'permission_callback' => 'vtables_admin_permission_callback',
+  ) );
+} );
+function vtables_delete_record_handler( WP_REST_Request $data ) {
+  global $wpdb;
+  $table_name = $wpdb->prefix . 'vtables';
+  $results = $wpdb->delete(
+    $table_name,
+    array('id' => $data['id']),
+  );
+  $response = array();
+  $response['id'] = $data['id'];
+  $rest_response = new WP_REST_Response(
+    array(
+      'success' => !!$results,
+      'data' => $response,
+    )
+  );
+  vtables_maybe_send_nocache_headers($rest_response);
+  return $rest_response;
+}
+/**
+ * CUSTOM PERMISSION CALLBACK: accessible only by administrator.
+ */
+function vtables_admin_permission_callback() {
+  if (
+    current_user_can('administrator') ||
+    current_user_can('editor') ||
+    current_user_can('shop_manager')
+  ) {
+    return true;
+  }
+  return new WP_Error(
+    'rest_forbidden',
+    'You do not have permissions to access this endpoint.',
+    array('status' => 401)
+  );
+}
+/**
+ * Add no-cache headers for requests so aggressive caches
+ * (LiteSpeed, reverse proxies) don't serve stale data.
+ */
+function vtables_maybe_send_nocache_headers( WP_REST_Response $response ) {
+  $response->header( 'Cache-Control', 'no-cache, no-store, must-revalidate, max-age=0' );
+  $response->header( 'Pragma', 'no-cache' );
+  $response->header( 'Expires', '0' );
+}
+    return $found !== null;
+  }
+}
+/**
+ * HELPER: per-table index map (column name -> array('type','slot')) read from
+ * wp_vtables.source.columns. Only columns flagged indexed with a 1..5 slot are
+ * returned. Drives the slot-backed sort/filter fast path in the query layer.
+ */
+if (!function_exists('vtables_table_index_map')) {
+  function vtables_table_index_map($table_id) {
+    global $wpdb;
+    $source = $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+      $wpdb->prepare( "SELECT source FROM {$wpdb->prefix}vtables WHERE id = %d", $table_id )
+    );
+    $decoded = json_decode($source, true);
+    $map = array();
+    if (is_array($decoded) && isset($decoded['columns']) && is_array($decoded['columns'])) {
+      foreach ($decoded['columns'] as $col) {
+        if (
+          isset($col['name'], $col['slot']) &&
+          !empty($col['indexed']) &&
+          (int) $col['slot'] >= 1 && (int) $col['slot'] <= 5
+        ) {
+          $type = isset($col['dataType']) ? (string) $col['dataType'] : 'text';
+          $map[(string) $col['name']] = array('type' => $type, 'slot' => (int) $col['slot']);
+        }
+      }
+    }
+    return $map;
+  }
+}
+/**
+ * HELPER: type-sniff each column from a sample of rows.
+ * Rules over the non-empty sample values: all-numeric -> number; all parseable
+ * dates -> date; only boolean-ish (0/1/true/false/yes/no) -> boolean; else text.
+ */
+if (!function_exists('vtables_sniff_column_types')) {
+  function vtables_sniff_column_types($headers, $sample_rows) {
+    $types = array();
+    if (!is_array($headers)) {
+      return $types;
+    }
+    $bool_set = array('0', '1', 'true', 'false', 'yes', 'no', 'y', 'n', 'on', 'off');
+    foreach ($headers as $header) {
+      $name = (string) $header;
+      $seen      = 0;
+      $all_num   = true;
+      $all_date  = true;
+      $all_bool  = true;
+      if (is_array($sample_rows)) {
+        foreach ($sample_rows as $row) {
+          if (!is_array($row) || !array_key_exists($name, $row)) {
+            continue;
+          }
+          $val = $row[$name];
+          if (is_array($val) || is_object($val)) {
+            $all_num = $all_date = $all_bool = false;
+            $seen++;
+            continue;
+          }
+          $str = trim((string) $val);
+          if ($str === '') {
+            continue; // empties don't constrain the type
+          }
+          $seen++;
+          if (!is_numeric($str)) {
+            $all_num = false;
+          }
+          if (!in_array(strtolower($str), $bool_set, true)) {
+            $all_bool = false;
+          }
+          // A bare integer is ambiguous as a date; require a non-numeric parseable
+          // string for the date guess so years/ids don't all become dates.
+          if (is_numeric($str) || strtotime($str) === false) {
+            $all_date = false;
+          }
+        }
+      }
+      if ($seen === 0) {
+        $types[$name] = 'text';
+      } elseif ($all_bool) {
+        $types[$name] = 'boolean';
+      } elseif ($all_num) {
+        $types[$name] = 'number';
+      } elseif ($all_date) {
+        $types[$name] = 'date';
+      } else {
+        $types[$name] = 'text';
+      }
+    }
+    return $types;
+  }
+}
+/**
+ * HELPER: count-cache key for a table + a query signature (the key scheme is
+ * shared with vTables Pro, which also folds search/filter into it).
+ */
+if (!function_exists('vtables_count_cache_key')) {
+  function vtables_count_cache_key($table_id, $signature) {
+    return 'vtables_count_' . (int) $table_id . '_' . md5((string) $signature);
+  }
+}
+/**
+ * HELPER: invalidate every cached COUNT for a table. Bumps a per-table version
+ * stored in an option; cache keys fold the version in, so a single bump expires
+ * all of a table's count transients without enumerating them. The option and
+ * transient names are the ones vTables Pro uses, so an edit made by either
+ * plugin expires both plugins' cached counts.
+ */
+if (!function_exists('vtables_count_cache_version')) {
+  function vtables_count_cache_version($table_id) {
+    $v = get_option('vtables_count_ver_' . (int) $table_id);
+    return $v ? (int) $v : 1;
+  }
+}
+if (!function_exists('vtables_invalidate_count_cache')) {
+  function vtables_invalidate_count_cache($table_id) {
+    $key = 'vtables_count_ver_' . (int) $table_id;
+    update_option($key, vtables_count_cache_version($table_id) + 1, false);
+  }
+}
+/**
+ * HELPER: paginated read over wp_vtables_source, in row order.
+ * Returns array('rows' => array<assoc row + vt_id>, 'total' => int).
+ * Search, sorting and filtering are vTables Pro features; this is the plain
+ * pagination path of Pro's query layer (same row order, same keyset cursor,
+ * same cached count), so page boundaries match whichever plugin serves them.
+ *
+ * @param array $args table_id, page, per_page, after_row_index
+ */
+if (!function_exists('vtables_query_source_rows')) {
+  function vtables_query_source_rows($args) {
+    global $wpdb;
+    $table_id = isset($args['table_id']) ? (int) $args['table_id'] : 0;
+    $page     = isset($args['page']) ? max(1, (int) $args['page']) : 1;
+    $per_page = isset($args['per_page']) ? (int) $args['per_page'] : vtables_default_per_page();
+    $per_page = max(1, min(1000, $per_page));
+    // Keyset cursor for flat-cost next/prev.
+    $after_row_index = isset($args['after_row_index']) && $args['after_row_index'] !== '' ? (int) $args['after_row_index'] : null;
+    // COUNT(*) caching: the total only changes on insert/delete, so cache it
+    // per table and invalidation version.
+    $cache_key = vtables_count_cache_key($table_id, vtables_count_cache_version($table_id) . '|all');
+    $total = get_transient($cache_key);
+    if ($total === false) {
+      $total = (int) $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+        $wpdb->prepare( "SELECT COUNT(*) FROM {$wpdb->prefix}vtables_source WHERE table_id = %d", $table_id )
+      );
+      set_transient($cache_key, $total, HOUR_IN_SECONDS);
+    } else {
+      $total = (int) $total;
+    }
+    if ($after_row_index !== null) {
+      // Uses the (table_id, row_index) index for flat cost at any depth.
+      $records = $wpdb->get_results( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+        $wpdb->prepare( "SELECT id, row_index, row_json FROM {$wpdb->prefix}vtables_source WHERE table_id = %d AND row_index > %d ORDER BY row_index ASC, id ASC LIMIT %d", $table_id, $after_row_index, $per_page ),
+        ARRAY_A
+      );
+    } else {
+      $records = $wpdb->get_results( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+        $wpdb->prepare( "SELECT id, row_index, row_json FROM {$wpdb->prefix}vtables_source WHERE table_id = %d ORDER BY row_index ASC, id ASC LIMIT %d OFFSET %d", $table_id, $per_page, ($page - 1) * $per_page ),
+        ARRAY_A
+      );
+    }
+    $rows = array();
+    if (is_array($records)) {
+      foreach ($records as $record) {
+        $decoded = json_decode($record['row_json'], true);
+        if (!is_array($decoded)) {
+          $decoded = array();
+        }
+        $decoded['vt_id']        = (int) $record['id'];
+        $decoded['vt_row_index'] = (int) $record['row_index'];
+        $rows[] = $decoded;
+      }
+    }
+    return array('rows' => $rows, 'total' => $total);
+  }
+}
+/**
+ * HELPER: build the lowercased free-text search blob for one row.
+ * Concatenates all cell values so a single LIKE can match across columns.
+ */
+if (!function_exists('vtables_row_search_blob')) {
+  function vtables_row_search_blob($row) {
+    if (!is_array($row)) {
+      $row = (array) $row;
+    }
+    $parts = array();
+    foreach ($row as $value) {
+      if (is_scalar($value)) {
+        $parts[] = (string) $value;
+      } elseif ($value !== null) {
+        $parts[] = wp_json_encode($value);
+      }
+    }
+    return strtolower(implode(' ', $parts));
+  }
+}
+/**
+ * HELPER: replace all source rows for a table.
+ * Deletes existing wp_vtables_source records for $table_id and re-inserts $rows as
+ * one record per row, batched so each INSERT packet stays small (well under
+ * max_allowed_packet). row_index is contiguous starting at 0.
+ */
+if (!function_exists('vtables_replace_source_rows')) {
+  function vtables_replace_source_rows($table_id, $rows) {
+    global $wpdb;
+    $source_table = $wpdb->prefix . 'vtables_source';
+    $wpdb->delete($source_table, array('table_id' => $table_id), array('%d')); // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    vtables_invalidate_count_cache($table_id);
+    if (empty($rows) || !is_array($rows)) {
+      return;
+    }
+    // Populate the typed slot sub-columns from the table's index map (if any).
+    $index_map = vtables_table_index_map($table_id);
+    $slot_cols = vtables_slot_columns();
+    $col_list  = array_merge(array('table_id', 'row_index', 'row_json', 'search_blob'), $slot_cols);
+    $batch_size = 500;
+    $index      = 0;
+    $values     = array();
+    $params     = array();
+    $flush = function () use (&$values, &$params, $source_table, $col_list, $wpdb) {
+      if (empty($values)) {
+        return;
+      }
+      $sql = "INSERT INTO {$source_table} (" . implode(', ', $col_list) . ") VALUES " . implode(', ', $values);
+      $wpdb->query( $wpdb->prepare($sql, $params) ); // phpcs:ignore WordPress.DB.DirectDatabaseQuery, WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- $sql holds only fixed column names and placeholders; every value goes through prepare()
+      $values = array();
+      $params = array();
+    };
+    foreach (array_values($rows) as $row) {
+      $row_json = wp_json_encode($row);
+      if ($row_json === false) {
+        continue;
+      }
+      $slot_values  = vtables_row_index_values($row, $index_map);
+      $placeholders = array('%d', '%d', '%s', '%s');
+      $params[]     = $table_id;
+      $params[]     = $index;
+      $params[]     = $row_json;
+      $params[]     = vtables_row_search_blob($row);
+      foreach ($slot_cols as $slot_col) {
+        if (!isset($slot_values[$slot_col]) || $slot_values[$slot_col] === null) {
+          $placeholders[] = 'NULL';
+        } else {
+          $placeholders[] = '%s';
+          $params[]       = $slot_values[$slot_col];
+        }
+      }
+      $values[] = '(' . implode(', ', $placeholders) . ')';
+      $index++;
+      if (count($values) >= $batch_size) {
+        $flush();
+      }
+    }
+    $flush();
+  }
+}
+/**
+ * HELPER: private working directory for uploads in progress.
+ * uploads/vtables_uploads/ holds chunks and assembled files only until the
+ * import has read them. Created on demand with an index.php and a deny-all
+ * .htaccess, so partial uploads are never browsable or directly fetchable.
+ * Returns the path with a trailing slash, or '' when it can't be created.
+ */
+if (!function_exists('vtables_uploads_dir')) {
+  function vtables_uploads_dir() {
+    $upload_info = wp_upload_dir();
+    $dir = trailingslashit($upload_info['basedir']) . 'vtables_uploads/';
+    if (!wp_mkdir_p($dir)) {
+      return '';
+    }
+    if (!file_exists($dir . 'index.php')) {
+      file_put_contents($dir . 'index.php', "<?php\n// Silence is golden.\n"); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_file_put_contents
+    }
+    if (!file_exists($dir . '.htaccess')) {
+      file_put_contents($dir . '.htaccess', "<IfModule mod_authz_core.c>\nRequire all denied\n</IfModule>\n<IfModule !mod_authz_core.c>\nDeny from all\n</IfModule>\n"); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_file_put_contents
+    }
+    return $dir;
+  }
+}
+/**
+ * HELPER: store an uploaded file (a $_FILES entry) as $dir . $filename.
+ * Goes through wp_handle_upload(), which runs the is_uploaded_file() check
+ * and the upload filters, pointed at $dir instead of the media library
+ * folders. Its type test is off: callers allowlist the extension themselves,
+ * and chunks are raw byte ranges. Returns the stored path, or '' on failure.
+ */
+if (!function_exists('vtables_store_uploaded_file')) {
+  function vtables_store_uploaded_file($file, $dir, $filename) {
+    require_once ABSPATH . 'wp-admin/includes/file.php';
+    $use_dir = function ($uploads) use ($dir) {
+      $uploads['path'] = untrailingslashit($dir);
+      return $uploads;
+    };
+    add_filter('upload_dir', $use_dir);
+    $result = wp_handle_upload($file, array(
+      'test_form'                => false,
+      'test_type'                => false,
+      'unique_filename_callback' => function () use ($filename) {
+        return $filename;
+      },
+    ));
+    remove_filter('upload_dir', $use_dir);
+    return empty($result['file']) ? '' : $result['file'];
+  }
+}
+/**
+ * HELPER: recursively remove a directory.
+ */
+if (!function_exists('vtables_remove_directory')) {
+  function vtables_remove_directory($dir) {
+    if (!is_dir($dir)) {
+      return;
+    }
+    $files = array_diff(scandir($dir), array('.', '..'));
+    foreach ($files as $file) {
+      $path = $dir . $file;
+      if (is_dir($path)) {
+        vtables_remove_directory($path . '/');
+      } else {
+        wp_delete_file($path);
+      }
+    }
+    rmdir($dir); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_rmdir
+  }
+}

vtables/trunk/includes/shortcode.html

-              r3133736
+              r3754379
 <!DOCTYPE html>
+<html lang="en-US">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>vTables</title>
+    <link
+      href="../dist/spa/css/material-icons-font-dist.css"
+      rel="stylesheet"
+      type="text/css"
+    />
+    <link
+      href="../dist/spa/css/quasar.prod.css"
+      rel="stylesheet"
+      type="text/css"
+    />
+    <link href="../dist/spa/css/vtables.css" rel="stylesheet" type="text/css" />
+  </head>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="robots" content="noindex, nofollow">
+  <title>vTables</title>
+</head>
+<body>
+<script>
+/*
+ * Compatibility stub for pages cached while vTables 0.2.x was active: its
+ * [vtables] iframe pointed here and carried the table id and the REST base
+ * URL as data attributes. Send such an iframe on to the current embed
+ * document (?vtables_embed=<id>, which works with and without pretty
+ * permalinks). Pages rendered by vTables 1.0 never load this file.
+ */
+(function () {
+  try {
+    var frame = window.frameElement;
+    if (!frame) return;
+  <body>
+    <div class="vtable q-pa-sm">
+      <q-table
+        v-if="selectedTable"
+        v-model:pagination="settings.bottom.initial"
+        :class="tableCssClasses"
+        :columns="columns"
+        :rows="rows"
+        :grid="settings.general.grid"
+        :bordered="settings.general.bordered"
+        :table-style="tableStyle"
+        :card-class="cardClasses"
+        :card-style="cardStyle"
+        :dark="settings.general.dark"
+        :dense="settings.general.dense"
+        :flat="settings.general.flat || !selectedTable.source.rows.length"
+        :square="settings.general.square"
+        :separator="settings.general.separator"
+      >
+        <!-- TOP -->
+        <template #top="props">
+          <div class="vtable__top | full-width flex" :class="topClasses">
+            <div v-if="!settings.top.hideTitle" class="col">
+              <h1
+                class="q-mt-xs q-mr-xs q-mb-xs q-ml-none text-h5"
+                :class="
+                    settings.top.textColor
+                      ? `text-${settings.top.textColor}`
+                      : `text-${settings.general.textColor}`
+                  "
+              >
+                {{ selectedTable.title }}
+              </h1>
+            </div>
+          </div>
+        </template>
+    var id = parseInt(frame.getAttribute('data-id'), 10);
+    var base = frame.getAttribute('data-baseurl') || '';
+    if (!id || id < 1 || !/^https?:\/\//i.test(base)) return;
+        <!-- BODY -->
+        <template #body="props">
+          <q-tr :props="props">
+            <q-td v-for="col in props.cols" :key="col.name" :props="props">
+              {{ props.row[col.field] || props.row[col.label] }}
+            </q-td>
+          </q-tr>
+        </template>
+    // rest_url() is either .../wp-json/ or .../?rest_route=/ (plain permalinks).
+    var home = base.replace(/\?rest_route=.*$/, '').replace(/wp-json\/?$/, '');
+    var separator = home.indexOf('?') === -1 ? '?' : '&';
+        <!-- GRID -->
+        <template v-if="settings.general.grid" #item="props">
+          <div
+            class="vtable__grid | q-pa-xs col-xs-12 col-sm-6 col-md-4 grid-style-transition"
+            :class="gridColumnWidth"
+          >
+            <q-card
+              class="q-pt-sm full-height"
+              :bordered="props.bordered"
+              :dark="props.dark"
+              :dense="props.dense"
+              :flat="props.flat"
+              :square="props.square"
+              :class="[
+                  `bg-${settingsGeneralBackgroundColor}`,
+                  props.cardClass,
+                ]"
+            >
+              <q-list>
+                <q-item v-for="col in props.cols" :key="col.name">
+                  <q-item-section v-if="col.value">
+                    <q-item-label
+                      caption
+                      :class="`text-${settingsGeneralTextColor}`"
+                    >
+                      {{ col.label }}
+                    </q-item-label>
+                    <q-item-label
+                      :class="[
+                          `text-${settingsGeneralTextColor}`,
+                        ]"
+                    >
+                      <div
+                        v-if="renderLinksAsLinks(col.value)"
+                        class="flex gap-5"
+                      >
+                        <template
+                          v-for="link in col.value.split(' ')"
+                          :key="link"
+                        >
+                          <a
+                            :href="link"
+                            target="_blank"
+                            :class="`text-${settings.content.buttonTextColor}`"
+                          >
+                            <span v-if="settings.content.buttonText">
+                              {{ settings.content.buttonText }}
+                            </span>
+                            <span v-else> Link </span>
+                          </a>
+                        </template>
+                      </div>
+                      <div v-else class="cell-value">{{ col.value }}</div>
+                    </q-item-label>
+                  </q-item-section>
+                </q-item>
+              </q-list>
+            </q-card>
+          </div>
+        </template>
+      </q-table>
+      <!-- Show empty table while loading -->
+      <q-table
+        v-else-if="loading"
+        :loading="loading"
+        :rows="[]"
+        :columns="[]"
+      ></q-table>
+      <!-- Show empty table if no data -->
+      <q-table
+        v-else
+        :rows="[]"
+        :columns="[]"
+        :no-data-label="noDataLabel"
+      ></q-table>
+    </div>
+    <!-- Add the following at the end of your body tag -->
+    <script src="../dist/spa/js/vue.global.prod.js"></script>
+    <script src="../dist/spa/js/quasar.umd.prod.js"></script>
+    <script>
+      const iframe = window.frameElement;
+      const dataId = iframe.getAttribute('data-id');
+      const dataCount = iframe.getAttribute('data-count');
+      const baseUrl = iframe.getAttribute('data-baseurl');
+      const table = document.querySelector('.vtable');
+      if (table) {
+        // Set attribute
+        table.setAttribute('id', 'vtable-' + dataCount);
+        // Add class
+        table.classList.add('vtable-' + dataId);
+      }
+      // Vue instance
+      const app = Vue.createApp({
+        data() {
+          return {
+            dataCount: null,
+            dataId: null,
+            selectedTable: null,
+            loading: false,
+            title: '',
+            columns: [],
+            rows: [],
+            settings: {},
+            initialPagination: {},
+            settingsSearchFilter: '',
+            showFullImage: false,
+            imagePath: '',
+            tableMaximized: false,
+          };
+        },
+        async mounted() {
+          this.loading = true;
+          this.dataCount = dataCount;
+          this.dataId = dataId;
+          // Fetch data
+          try {
+            this.selectedTable = await this.getTable(dataId);
+          } catch (error) {
+            console.log(error);
+          }
+          this.loading = false;
+          // Set height of iframe if no data
+          if (!this.selectedTable) {
+            iframe.style.height = '70px';
+            return;
+          }
+          // Descruct data
+          const { source, settings, title } = this.selectedTable;
+          // Assign data
+          this.columns = source.columns;
+          this.rows = source.rows;
+          this.settings = settings;
+          this.initialPagination = settings.bottom.initial;
+          this.title = title;
+          // Dynamic Height
+          this.$nextTick(() => {
+            const bodyHeight = document.body.clientHeight;
+            iframe.style.minHeight = bodyHeight + 20 + 'px';
+          });
+          // Dynamic width
+          if (this.settings.dimensions.tableMaxWidth) {
+            iframe.style.maxWidth =
+              this.settings.dimensions.tableMaxWidth + 'px';
+          }
+          // Add event listener
+          window.addEventListener('resize', this.handleResize);
+        },
+        beforeDestroy() {
+          // Destroy event listener
+          window.removeEventListener('resize', this.handleResize);
+        },
+        computed: {
+          // Table style computed prop.
+          tableStyle() {
+            if (Object.keys(this.settings).length) {
+              return {
+                height: this.settings.dimensions.tableHeight
+                  ? this.settings.dimensions.tableHeight + 'px'
+                  : '100%',
+              };
+            }
+            return '';
+          },
+          // No data label computed prop.
+          noDataLabel() {
+            if (!this.selectedTable) {
+              return 'Table with this shortcode does not exist';
+            }
+            return 'No data available';
+          },
+          // Card classes computed prop.
+          cardClasses() {
+            if (Object.keys(this.settings).length) {
+              const cssClasses = [this.settings.customCss.cardClass];
+              if (this.settings.general.backgroundColor) {
+                cssClasses.push(`bg-${this.settings.general.backgroundColor}`);
+              }
+              if (this.settings.general.textColor) {
+                cssClasses.push(`text-${this.settings.general.textColor}`);
+              }
+              return cssClasses;
+            }
+            return [];
+          },
+          // Card style computed prop.
+          cardStyle() {
+            if (Object.keys(this.settings).length) {
+              return {
+                maxWidth: this.settings.general.tableMaxWidth
+                  ? this.settings.general.tableMaxWidth + 'px'
+                  : '100%',
+              };
+            }
+            return '';
+          },
+          // Top classes computed prop.
+          topClasses() {
+            if (Object.keys(this.settings).length) {
+              const cssClasses = [];
+              if (this.settings.top.topBackgroundColor) {
+                cssClasses.push(`bg-${this.settings.top.topBackgroundColor}`);
+              }
+              if (this.settings.top.textColor) {
+                cssClasses.push(`text-${this.settings.top.textColor}`);
+              }
+              return cssClasses;
+            }
+            return [];
+          },
+          // Table CSS classes computed prop.
+          tableCssClasses() {
+            const isAdminbarPresented = document.querySelector('#wpadminbar');
+            return [
+              { 'sticky-header-table': this.settings.top.stickyHeader },
+              {
+                'sticky-column-first': this.settings.columns.stickyFirstColumn,
+              },
+              { 'sticky-column-last': this.settings.columns.stickyLastColumn },
+              {
+                'admin-bar-presented-on-fullscreen':
+                  this.tableMaximized && isAdminbarPresented,
+              },
+            ];
+          },
+          // Grid column width computed prop.
+          gridColumnWidth() {
+            if (
+              this.settings.bottom.initial &&
+              this.settings.bottom.initial.rowsPerPage
+            ) {
+              return `col-sm-${12 / this.settings.bottom.initial.rowsPerPage}`;
+            }
+            return 'col-sm-3';
+          },
+          // General text color computed prop.
+          settingsGeneralTextColor() {
+            if (Object.keys(this.settings).length) {
+              return this.settings.general.textColor;
+            }
+            return '';
+          },
+          // General background color computed prop.
+          settingsGeneralBackgroundColor() {
+            if (Object.keys(this.settings).length) {
+              return this.settings.general.backgroundColor;
+            }
+            return '';
+          },
+        },
+        setup() {
+          /**
+           * FETCH TABLE
+           */
+          async function getTable(id) {
+            const base = baseUrl || '/wp-json/';
+            const post = await fetch(`${base}vtables/v1/tables/${id}`).then(
+              (resp) => resp.json()
+            );
+            if (!post || post?.data?.status === 404) {
+              return;
+            }
+            return post.data;
+          }
+          /**
+           * CHECK IF LINK
+           * @param str
+           */
+          function getLinkType(str) {
+            const regex = /http|https|jpg|jpeg|png|gif|bmp|tiff|webp|svg/i;
+            if (!regex.test(str)) {
+              return;
+            }
+            const linkPattern = /^(https?:\/\/\S+)$/i;
+            const imageExtensions = /\.(jpg|jpeg|png|gif|bmp|tiff|webp|svg)$/i;
+            const strArr = str.split(' ');
+            const isLinks = strArr.every((el) => linkPattern.test(el));
+            const isImages = strArr.every((el) => imageExtensions.test(el));
+            if (isImages) {
+              return 'images';
+            }
+            if (isLinks) {
+              return 'links';
+            }
+          }
+          /**
+           * RENDER LINKS AS LINKS
+           * @param value
+           */
+          function renderLinksAsLinks(value) {
+            if (!Object.keys(this.settings).length) {
+              return;
+            }
+            return (
+              (!this.settings.content.turnLinksToImages &&
+                getLinkType(value) === 'images') ||
+              getLinkType(value) === 'links'
+            );
+          }
+          /**
+           * HANDLE RESIZE
+           */
+          function handleResize() {
+            const bodyHeight = document.body.clientHeight;
+            iframe.style.minHeight = bodyHeight + 20 + 'px';
+          }
+          return {
+            getTable,
+            renderLinksAsLinks,
+            getLinkType,
+            handleResize,
+          };
+        },
+      });
+      app.use(Quasar);
+      app.mount('#vtable-' + dataCount);
+    </script>
+  </body>
+    window.location.replace(home + separator + 'vtables_embed=' + id);
+  } catch (e) {
+    // Cross-origin parent: nothing to read; the frame stays blank.
+  }
+})();
+</script>
+</body>
 </html>

vtables/trunk/index.html

r3134061	r3754379
12	12	content="user-scalable=no, initial-scale=1, maximum-scale=1, minimum-scale=1, width=device-width<% if (ctx.mode.cordova \|\| ctx.mode.capacitor) { %>, viewport-fit=cover<% } %>"
13	13	/>
	14	<link rel="stylesheet" href="./public/css/material-icons-font-dist.css" />
14	15	</head>
15	16	<body>

vtables/trunk/package-lock.json

-              r3036822
+              r3754379
+{
   "name": "vtables",
   "version": "0.0.1",
+  "version": "3.0.0",
   "lockfileVersion": 3,
   "requires": true,
 …
     "": {
       "name": "vtables",
+      "version": "0.0.1",
+      "version": "3.0.0",
+      "license": "GPL-3.0-only",
       "dependencies": {
         "@quasar/extras": "^1.0.0",
         "@types/papaparse": "^5.3.9",
-        "@types/wpapi": "^1.1.1",
         "@vuelidate/core": "^2.0.3",
         "@vuelidate/validators": "^2.0.3",
 …
         "vue": "^3.0.0",
         "vue-i18n": "^9.2.2",
+        "vue-router": "^4.0.0",
+        "wpapi": "^1.2.2"
+        "vue-router": "^4.0.0"
       },
       "devDependencies": {
 …
         "eslint-plugin-vue": "^9.0.0",
         "prettier": "^2.5.1",
+        "typescript": "5.0.4"
+        "typescript": "5.0.4",
+        "vue-tsc": "^1.8.27"
       },
       "engines": {
 …
       "license": "MIT"
     },
-    "node_modules/@types/wpapi": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@types/wpapi/-/wpapi-1.1.1.tgz",
-      "integrity": "sha512-Ek1siuveAaN/iVoRvGbSGWNBg7RXQoz4Am1C3nnoXVA33f/0+9GibJq/xNBWsInZk5mNVqySkeYVco5C1KMqog==",
-      "license": "MIT"
-    },
     "node_modules/@typescript-eslint/eslint-plugin": {
       "version": "5.59.11",
 …
+      }
     },
+    "node_modules/@volar/language-core": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@volar/language-core/-/language-core-1.11.1.tgz",
+      "integrity": "sha512-dOcNn3i9GgZAcJt43wuaEykSluAuOkQgzni1cuxLxTV0nJKanQztp7FxyswdRILaKH+P2XZMPRp2S4MV/pElCw==",
+      "dev": true,
+      "dependencies": {
+        "@volar/source-map": "1.11.1"
+      }
+    },
+    "node_modules/@volar/source-map": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@volar/source-map/-/source-map-1.11.1.tgz",
+      "integrity": "sha512-hJnOnwZ4+WT5iupLRnuzbULZ42L7BWWPMmruzwtLhJfpDVoZLjNBxHDi2sY2bgZXCKlpU5XcsMFoYrsQmPhfZg==",
+      "dev": true,
+      "dependencies": {
+        "muggle-string": "^0.3.1"
+      }
+    },
+    "node_modules/@volar/typescript": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@volar/typescript/-/typescript-1.11.1.tgz",
+      "integrity": "sha512-iU+t2mas/4lYierSnoFOeRFQUhAEMgsFuQxoxvwn5EdQopw43j+J27a4lt9LMInx1gLJBC6qL14WYGlgymaSMQ==",
+      "dev": true,
+      "dependencies": {
+        "@volar/language-core": "1.11.1",
+        "path-browserify": "^1.0.1"
+      }
+    },
     "node_modules/@vue/compiler-core": {
       "version": "3.3.4",
 …
       "license": "MIT"
     },
+    "node_modules/@vue/language-core": {
+      "version": "1.8.27",
+      "resolved": "https://registry.npmjs.org/@vue/language-core/-/language-core-1.8.27.tgz",
+      "integrity": "sha512-L8Kc27VdQserNaCUNiSFdDl9LWT24ly8Hpwf1ECy3aFb9m6bDhBGQYOujDm21N7EW3moKIOKEanQwe1q5BK+mA==",
+      "dev": true,
+      "dependencies": {
+        "@volar/language-core": "~1.11.1",
+        "@volar/source-map": "~1.11.1",
+        "@vue/compiler-dom": "^3.3.0",
+        "@vue/shared": "^3.3.0",
+        "computeds": "^0.0.1",
+        "minimatch": "^9.0.3",
+        "muggle-string": "^0.3.1",
+        "path-browserify": "^1.0.1",
+        "vue-template-compiler": "^2.7.14"
+      },
+      "peerDependencies": {
+        "typescript": "*"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vue/language-core/node_modules/brace-expansion": {
+      "version": "2.1.7",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.7.tgz",
+      "integrity": "sha512-uZbew1NqdmPDTMJ8ah1y+b+9QEJrfkXFk3RcTQw3X0jW/xRUvFKsg1CfQdSYGdTbXZWExtU3J3ccxtnfw1Fi0g==",
+      "dev": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/@vue/language-core/node_modules/minimatch": {
+      "version": "9.0.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+      "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+      "dev": true,
+      "dependencies": {
+        "brace-expansion": "^2.0.2"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/@vue/reactivity": {
       "version": "3.3.4",
 …
       "engines": {
         "node": ">=0.4.0"
+      }
+    },
+    "node_modules/agent-base": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",
+      "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
+      "dependencies": {
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
     },
 …
     },
     "node_modules/axios": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/axios/-/axios-1.4.0.tgz",
       "integrity": "sha512-S4XCWMEmzvo64T9GfvQDOXgYRDJ/wsSZc7Jvdgx5u1sd0JwsuPLqb3SYmusag+edF6ziyMensPVqLTSc1PiSEA==",
       "license": "MIT",
       "dependencies": {
         "follow-redirects": "^1.15.0",
         "form-data": "^4.0.0",
         "proxy-from-env": "^1.1.0"
+      "version": "1.18.1",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.18.1.tgz",
+      "integrity": "sha512-3nTvFlvpn9Zu/RkHUqtc7/+al4UpRW5az71ap5zccp6e8RAYEzhMTecX8Dz1wWDYrPpUoB1HAQEGEAEvUr7S9g==",
+      "dependencies": {
+        "follow-redirects": "^1.16.0",
+        "form-data": "^4.0.5",
+        "https-proxy-agent": "^5.0.1",
+        "proxy-from-env": "^2.1.0"
+      }
     },
 …
       "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz",
       "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
 …
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
     },
 …
       "license": "MIT"
     },
-    "node_modules/component-emitter": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz",
-      "integrity": "sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==",
-      "license": "MIT"
-    },
     "node_modules/compress-commons": {
       "version": "4.1.1",
 …
       "license": "MIT"
     },
+    "node_modules/computeds": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/computeds/-/computeds-0.0.1.tgz",
+      "integrity": "sha512-7CEBgcMjVmitjYo5q8JTJVra6X5mQ20uTThdK+0kR7UEaDrAWEQcRiBtWJzga4eRpP6afNwwLsX2SET2JhVB1Q==",
+      "dev": true
+    },
     "node_modules/concat-map": {
       "version": "0.0.1",
 …
       "license": "MIT"
     },
-    "node_modules/cookiejar": {
-      "version": "2.1.4",
-      "resolved": "https://registry.npmjs.org/cookiejar/-/cookiejar-2.1.4.tgz",
-      "integrity": "sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw==",
-      "license": "MIT"
-    },
     "node_modules/core-util-is": {
       "version": "1.0.3",
 …
       "license": "MIT"
     },
+    "node_modules/de-indent": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/de-indent/-/de-indent-1.0.2.tgz",
+      "integrity": "sha512-e/1zu3xH5MQryN2zdVaF0OrdNLUbvWxzMbi+iNA6Bky7l1RoP8a2fIbRocyHclXt/arDrrR6lL3TqFD9pMQTsg==",
+      "dev": true
+    },
     "node_modules/debug": {
       "version": "4.3.4",
 …
+      }
     },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/ee-first": {
       "version": "1.1.1",
 …
       "dependencies": {
         "once": "^1.4.0"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz",
+      "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
     },
 …
     },
     "node_modules/follow-redirects": {
       "version": "1.15.2",
       "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz",
       "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==",
+      "version": "1.16.0",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.16.0.tgz",
+      "integrity": "sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==",
       "funding": [
+        {
 …
+        }
       ],
-      "license": "MIT",
       "engines": {
         "node": ">=4.0"
 …
     },
     "node_modules/form-data": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
+      "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+      "license": "MIT",
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.6.tgz",
+      "integrity": "sha512-vKatAh4SlVfgbv+YtmhiRjhEMJsYpsG1Y2rMQtR+SVSbytsSD1YGzDIcrAJmdFec88u/+VoGmxnl+80gL1tRCQ==",
       "dependencies": {
         "asynckit": "^0.4.0",
         "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.4",
+        "mime-types": "^2.1.35"
       },
       "engines": {
         "node": ">= 6"
+      }
-    },
-    "node_modules/formidable": {
-      "version": "1.2.6",
-      "resolved": "https://registry.npmjs.org/formidable/-/formidable-1.2.6.tgz",
-      "integrity": "sha512-KcpbcpuLNOwrEjnbpMC0gS+X8ciDoZE1kkqzat4a8vrprf+s9pKNQ/QIwWfbfs4ltgmFl3MD177SNTkve3BwGQ==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://ko-fi.com/tunnckoCore/commissions"
+      }
     },
 …
     },
     "node_modules/function-bind": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
+      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
+      "license": "MIT"
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
     },
     "node_modules/get-caller-file": {
 …
     },
     "node_modules/get-intrinsic": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.1.tgz",
+      "integrity": "sha512-2DcsyfABl+gVHEfCOaTrWgyt+tb6MSEGmKq+kI5HwLbIYgjgmMcV8KQ41uaKz1xxUcn9tJtgFbQUEVcEbd0FYw==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.1",
+        "has": "^1.0.3",
+        "has-proto": "^1.0.1",
+        "has-symbols": "^1.0.3"
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
       },
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
     },
 …
+      }
     },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/graceful-fs": {
       "version": "4.2.11",
 …
       "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
       "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
 …
+      }
     },
+    "node_modules/has-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz",
+      "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==",
+      "license": "MIT",
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
       "engines": {
         "node": ">= 0.4"
 …
+      }
     },
+    "node_modules/has-symbols": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
+      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
+      "license": "MIT",
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
       "engines": {
         "node": ">= 0.4"
 …
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
     },
 …
       "engines": {
         "node": ">= 0.8"
+      }
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",
+      "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==",
+      "dependencies": {
+        "agent-base": "6",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
     },
 …
       "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "dev": true,
       "license": "ISC"
     },
 …
+      }
     },
-    "node_modules/li": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/li/-/li-1.3.0.tgz",
-      "integrity": "sha512-z34TU6GlMram52Tss5mt1m//ifRIpKH5Dqm7yUVOdHI+BQCs9qGPHFaCUTIzsWX7edN30aa2WrPwR7IO10FHaw==",
-      "license": "MIT"
-    },
     "node_modules/locate-path": {
       "version": "6.0.0",
 …
+      }
     },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/media-typer": {
       "version": "0.3.0",
 …
       "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
       "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "dev": true,
       "license": "MIT",
       "engines": {
 …
+      }
     },
-    "node_modules/mime": {
-      "version": "2.6.0",
-      "resolved": "https://registry.npmjs.org/mime/-/mime-2.6.0.tgz",
-      "integrity": "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==",
-      "license": "MIT",
-      "bin": {
-        "mime": "cli.js"
-      },
-      "engines": {
-        "node": ">=4.0.0"
+      }
-    },
     "node_modules/mime-db": {
       "version": "1.52.0",
 …
       "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
       "license": "MIT"
+    },
+    "node_modules/muggle-string": {
+      "version": "0.3.1",
+      "resolved": "https://registry.npmjs.org/muggle-string/-/muggle-string-0.3.1.tgz",
+      "integrity": "sha512-ckmWDJjphvd/FvZawgygcUeQCxzvohjFO5RxTjj4eq8kw359gFF3E1brjfI+viLMxss5JrHTDRHZvu2/tuy0Qg==",
+      "dev": true
     },
     "node_modules/mute-stream": {
 …
       "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz",
       "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==",
+      "dev": true,
       "license": "MIT",
       "funding": {
 …
+      }
     },
-    "node_modules/parse-link-header": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/parse-link-header/-/parse-link-header-1.0.1.tgz",
-      "integrity": "sha512-Z0gpfHmwCIKDr5rRzjypL+p93aHVWO7e+0rFcUl9E3sC67njjs+xHFenuboSXZGlvYtmQqRzRaE3iFpTUnLmFQ==",
-      "license": "MIT",
-      "dependencies": {
-        "xtend": "~4.0.1"
+      }
-    },
     "node_modules/parseurl": {
       "version": "1.3.3",
 …
         "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-browserify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz",
+      "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==",
+      "dev": true
     },
     "node_modules/path-exists": {
 …
     },
     "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-2.1.0.tgz",
+      "integrity": "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==",
+      "engines": {
+        "node": ">=10"
+      }
     },
     "node_modules/punycode": {
 …
       "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
       "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
 …
       "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
       "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "dev": true,
       "funding": [
+        {
 …
       "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz",
       "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
 …
       "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
       "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
 …
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
+      }
-    },
-    "node_modules/superagent": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/superagent/-/superagent-4.1.0.tgz",
-      "integrity": "sha512-FT3QLMasz0YyCd4uIi5HNe+3t/onxMyEho7C3PSqmti3Twgy2rXT4fmkTz6wRL6bTF4uzPcfkUCa8u4JWHw8Ag==",
-      "license": "MIT",
-      "dependencies": {
-        "component-emitter": "^1.2.0",
-        "cookiejar": "^2.1.2",
-        "debug": "^4.1.0",
-        "form-data": "^2.3.3",
-        "formidable": "^1.2.0",
-        "methods": "^1.1.1",
-        "mime": "^2.4.0",
-        "qs": "^6.6.0",
-        "readable-stream": "^3.0.6"
-      },
-      "engines": {
-        "node": ">= 6.0"
+      }
-    },
-    "node_modules/superagent/node_modules/form-data": {
-      "version": "2.5.1",
-      "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.5.1.tgz",
-      "integrity": "sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA==",
-      "license": "MIT",
-      "dependencies": {
-        "asynckit": "^0.4.0",
-        "combined-stream": "^1.0.6",
-        "mime-types": "^2.1.12"
-      },
-      "engines": {
-        "node": ">= 0.12"
+      }
-    },
-    "node_modules/superagent/node_modules/qs": {
-      "version": "6.11.2",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.2.tgz",
-      "integrity": "sha512-tDNIz22aBzCDxLtVH++VnTfzxlfeK5CbqohpSqpJgj1Wg/cQbStNAz3NuqCs5vV+pjBsK4x4pN9HlVh7rcYRiA==",
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "side-channel": "^1.0.4"
-      },
-      "engines": {
-        "node": ">=0.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+      }
     },
 …
       "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
       "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "dev": true,
       "license": "MIT"
     },
 …
+      }
     },
+    "node_modules/vue-template-compiler": {
+      "version": "2.7.16",
+      "resolved": "https://registry.npmjs.org/vue-template-compiler/-/vue-template-compiler-2.7.16.tgz",
+      "integrity": "sha512-AYbUWAJHLGGQM7+cNTELw+KsOG9nl2CnSv467WobS5Cv9uk3wFcnr1Etsz2sEIHEZvw1U+o9mRlEO6QbZvUPGQ==",
+      "dev": true,
+      "dependencies": {
+        "de-indent": "^1.0.2",
+        "he": "^1.2.0"
+      }
+    },
+    "node_modules/vue-tsc": {
+      "version": "1.8.27",
+      "resolved": "https://registry.npmjs.org/vue-tsc/-/vue-tsc-1.8.27.tgz",
+      "integrity": "sha512-WesKCAZCRAbmmhuGl3+VrdWItEvfoFIPXOvUJkjULi+x+6G/Dy69yO3TBRJDr9eUlmsNAwVmxsNZxvHKzbkKdg==",
+      "dev": true,
+      "dependencies": {
+        "@volar/typescript": "~1.11.1",
+        "@vue/language-core": "1.8.27",
+        "semver": "^7.5.4"
+      },
+      "bin": {
+        "vue-tsc": "bin/vue-tsc.js"
+      },
+      "peerDependencies": {
+        "typescript": "*"
+      }
+    },
     "node_modules/wcwidth": {
       "version": "1.0.1",
 …
+      }
     },
-    "node_modules/wpapi": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/wpapi/-/wpapi-1.2.2.tgz",
-      "integrity": "sha512-lkgi8Gjav3SArrCkNpG61ZnmCyamXKB+SjaR8tAoHhSZbJRTeabIlsdqUUAN3JGbVY3ht8p+EGdpCFIaanI5+w==",
-      "license": "MIT",
-      "dependencies": {
-        "li": "^1.3.0",
-        "parse-link-header": "^1.0.1",
-        "qs": "^6.6.0",
-        "superagent": "^4.0.0"
+      }
-    },
-    "node_modules/wpapi/node_modules/qs": {
-      "version": "6.11.2",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.2.tgz",
-      "integrity": "sha512-tDNIz22aBzCDxLtVH++VnTfzxlfeK5CbqohpSqpJgj1Wg/cQbStNAz3NuqCs5vV+pjBsK4x4pN9HlVh7rcYRiA==",
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "side-channel": "^1.0.4"
-      },
-      "engines": {
-        "node": ">=0.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+      }
-    },
     "node_modules/wrap-ansi": {
       "version": "7.0.0",
 …
       "engines": {
         "node": ">=12"
+      }
-    },
-    "node_modules/xtend": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
-      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.4"
+      }
     },

vtables/trunk/package.json

-              r3576926
+              r3754379
+{
   "name": "vtables",
   "version": "0.2.1",
   "description": "Create stunning, interactive tables effortlessly. No coding required. The ultimate WordPress plugin, lets you design powerful tables in a few clicks. Transform your data visualization now.",
+  "version": "0.3",
+  "description": "Build interactive data tables from CSV, Excel and JSON files, or from scratch, and embed them anywhere with a shortcode.",
   "productName": "vTables",
+  "author": "iamvs.com",
+  "author": "vTables",
+  "license": "GPL-3.0-only",
   "private": true,
   "scripts": {
     "lint": "eslint --ext .js,.ts,.vue ./",
     "format": "prettier --write \"**/*.{js,ts,vue,scss,html,md,json}\" --ignore-path .gitignore",
+    "typecheck": "vue-tsc --noEmit",
     "test": "echo \"No test specified\" && exit 0",
     "dev": "quasar dev",
     "build": "quasar build",
+    "build": "quasar build && node scripts/patch-asset-base.mjs",
     "release": "./release.sh"
   },
 …
     "@quasar/extras": "^1.0.0",
     "@types/papaparse": "^5.3.9",
-    "@types/wpapi": "^1.1.1",
     "@vuelidate/core": "^2.0.3",
     "@vuelidate/validators": "^2.0.3",
 …
     "pinia": "^2.0.11",
     "quasar": "^2.6.0",
-    "rollbar": "^2.26.2",
     "vue": "^3.0.0",
     "vue-i18n": "^9.2.2",
+    "vue-router": "^4.0.0",
+    "woocommerce-rest-ts-api": "^7.0.0",
+    "wpapi": "^1.2.2"
+    "vue-router": "^4.0.0"
   },
   "devDependencies": {
 …
     "eslint-plugin-vue": "^9.0.0",
     "prettier": "^2.5.1",
+    "typescript": "5.0.4"
+    "typescript": "5.0.4",
+    "vue-tsc": "^1.8.27"
   },
   "engines": {

vtables/trunk/public/css/vtables.css

-              r3212270
+              r3754379
+:root {
+  --red: #f44336;
+  --red-1: #ffebee;
+  --red-2: #ffcdd2;
+  --red-3: #ef9a9a;
+  --red-4: #e57373;
+  --red-5: #ef5350;
+  --red-6: #f44336;
+  --red-7: #e53935;
+  --red-8: #d32f2f;
+  --red-9: #c62828;
+  --red-10: #b71c1c;
+  --red-11: #ff8a80;
+  --red-12: #ff5252;
+  --red-13: #ff1744;
+  --red-14: #d50000;
+  --pink: #e91e63;
+  --pink-1: #fce4ec;
+  --pink-2: #f8bbd0;
+  --pink-3: #f48fb1;
+  --pink-4: #f06292;
+  --pink-5: #ec407a;
+  --pink-6: #e91e63;
+  --pink-7: #d81b60;
+  --pink-8: #c2185b;
+  --pink-9: #ad1457;
+  --pink-10: #880e4f;
+  --pink-11: #ff80ab;
+  --pink-12: #ff4081;
+  --pink-13: #f50057;
+  --pink-14: #c51162;
+  --purple: #9c27b0;
+  --purple-1: #f3e5f5;
+  --purple-2: #e1bee7;
+  --purple-3: #ce93d8;
+  --purple-4: #ba68c8;
+  --purple-5: #ab47bc;
+  --purple-6: #9c27b0;
+  --purple-7: #8e24aa;
+  --purple-8: #7b1fa2;
+  --purple-9: #6a1b9a;
+  --purple-10: #4a148c;
+  --purple-11: #ea80fc;
+  --purple-12: #e040fb;
+  --purple-13: #d500f9;
+  --purple-14: #aa00ff;
+  --deep-purple: #673ab7;
+  --deep-purple-1: #ede7f6;
+  --deep-purple-2: #d1c4e9;
+  --deep-purple-3: #b39ddb;
+  --deep-purple-4: #9575cd;
+  --deep-purple-5: #7e57c2;
+  --deep-purple-6: #673ab7;
+  --deep-purple-7: #5e35b1;
+  --deep-purple-8: #512da8;
+  --deep-purple-9: #4527a0;
+  --deep-purple-10: #311b92;
+  --deep-purple-11: #b388ff;
+  --deep-purple-12: #7c4dff;
+  --deep-purple-13: #651fff;
+  --deep-purple-14: #6200ea;
+  --indigo: #3f51b5;
+  --indigo-1: #e8eaf6;
+  --indigo-2: #c5cae9;
+  --indigo-3: #9fa8da;
+  --indigo-4: #7986cb;
+  --indigo-5: #5c6bc0;
+  --indigo-6: #3f51b5;
+  --indigo-7: #3949ab;
+  --indigo-8: #303f9f;
+  --indigo-9: #283593;
+  --indigo-10: #1a237e;
+  --indigo-11: #8c9eff;
+  --indigo-12: #536dfe;
+  --indigo-13: #3d5afe;
+  --indigo-14: #304ffe;
+  --blue: #2196f3;
+  --blue-1: #e3f2fd;
+  --blue-2: #bbdefb;
+  --blue-3: #90caf9;
+  --blue-4: #64b5f6;
+  --blue-5: #42a5f5;
+  --blue-6: #2196f3;
+  --blue-7: #1e88e5;
+  --blue-8: #1976d2;
+  --blue-9: #1565c0;
+  --blue-10: #0d47a1;
+  --blue-11: #82b1ff;
+  --blue-12: #448aff;
+  --blue-13: #2979ff;
+  --blue-14: #2962ff;
+  --light-blue: #03a9f4;
+  --light-blue-1: #e1f5fe;
+  --light-blue-2: #b3e5fc;
+  --light-blue-3: #81d4fa;
+  --light-blue-4: #4fc3f7;
+  --light-blue-5: #29b6f6;
+  --light-blue-6: #03a9f4;
+  --light-blue-7: #039be5;
+  --light-blue-8: #0288d1;
+  --light-blue-9: #0277bd;
+  --light-blue-10: #01579b;
+  --light-blue-11: #80d8ff;
+  --light-blue-12: #40c4ff;
+  --light-blue-13: #00b0ff;
+  --light-blue-14: #0091ea;
+  --cyan: #00bcd4;
+  --cyan-1: #e0f7fa;
+  --cyan-2: #b2ebf2;
+  --cyan-3: #80deea;
+  --cyan-4: #4dd0e1;
+  --cyan-5: #26c6da;
+  --cyan-6: #00bcd4;
+  --cyan-7: #00acc1;
+  --cyan-8: #0097a7;
+  --cyan-9: #00838f;
+  --cyan-10: #006064;
+  --cyan-11: #84ffff;
+  --cyan-12: #18ffff;
+  --cyan-13: #00e5ff;
+  --cyan-14: #00b8d4;
+  --teal: #009688;
+  --teal-1: #e0f2f1;
+  --teal-2: #b2dfdb;
+  --teal-3: #80cbc4;
+  --teal-4: #4db6ac;
+  --teal-5: #26a69a;
+  --teal-6: #009688;
+  --teal-7: #00897b;
+  --teal-8: #00796b;
+  --teal-9: #00695c;
+  --teal-10: #004d40;
+  --teal-11: #a7ffeb;
+  --teal-12: #64ffda;
+  --teal-13: #1de9b6;
+  --teal-14: #00bfa5;
+  --green: #4caf50;
+  --green-1: #e8f5e9;
+  --green-2: #c8e6c9;
+  --green-3: #a5d6a7;
+  --green-4: #81c784;
+  --green-5: #66bb6a;
+  --green-6: #4caf50;
+  --green-7: #43a047;
+  --green-8: #388e3c;
+  --green-9: #2e7d32;
+  --green-10: #1b5e20;
+  --green-11: #b9f6ca;
+  --green-12: #69f0ae;
+  --green-13: #00e676;
+  --green-14: #00c853;
+  --light-green: #8bc34a;
+  --light-green-1: #f1f8e9;
+  --light-green-2: #dcedc8;
+  --light-green-3: #c5e1a5;
+  --light-green-4: #aed581;
+  --light-green-5: #9ccc65;
+  --light-green-6: #8bc34a;
+  --light-green-7: #7cb342;
+  --light-green-8: #689f38;
+  --light-green-9: #558b2f;
+  --light-green-10: #33691e;
+  --light-green-11: #ccff90;
+  --light-green-12: #b2ff59;
+  --light-green-13: #76ff03;
+  --light-green-14: #64dd17;
+  --lime: #cddc39;
+  --lime-1: #f9fbe7;
+  --lime-2: #f0f4c3;
+  --lime-3: #e6ee9c;
+  --lime-4: #dce775;
+  --lime-5: #d4e157;
+  --lime-6: #cddc39;
+  --lime-7: #c0ca33;
+  --lime-8: #afb42b;
+  --lime-9: #9e9d24;
+  --lime-10: #827717;
+  --lime-11: #f4ff81;
+  --lime-12: #eeff41;
+  --lime-13: #c6ff00;
+  --lime-14: #aeea00;
+  --yellow: #ffeb3b;
+  --yellow-1: #fffde7;
+  --yellow-2: #fff9c4;
+  --yellow-3: #fff59d;
+  --yellow-4: #fff176;
+  --yellow-5: #ffee58;
+  --yellow-6: #ffeb3b;
+  --yellow-7: #fdd835;
+  --yellow-8: #fbc02d;
+  --yellow-9: #f9a825;
+  --yellow-10: #f57f17;
+  --yellow-11: #ffff8d;
+  --yellow-12: #ffff00;
+  --yellow-13: #ffea00;
+  --yellow-14: #ffd600;
+  --amber: #ffc107;
+  --amber-1: #fff8e1;
+  --amber-2: #ffecb3;
+  --amber-3: #ffe082;
+  --amber-4: #ffd54f;
+  --amber-5: #ffca28;
+  --amber-6: #ffc107;
+  --amber-7: #ffb300;
+  --amber-8: #ffa000;
+  --amber-9: #ff8f00;
+  --amber-10: #ff6f00;
+  --amber-11: #ffe57f;
+  --amber-12: #ffd740;
+  --amber-13: #ffc400;
+  --amber-14: #ffab00;
+  --orange: #ff9800;
+  --orange-1: #fff3e0;
+  --orange-2: #ffe0b2;
+  --orange-3: #ffcc80;
+  --orange-4: #ffb74d;
+  --orange-5: #ffa726;
+  --orange-6: #ff9800;
+  --orange-7: #fb8c00;
+  --orange-8: #f57c00;
+  --orange-9: #ef6c00;
+  --orange-10: #e65100;
+  --orange-11: #ffd180;
+  --orange-12: #ffab40;
+  --orange-13: #ff9100;
+  --orange-14: #ff6d00;
+  --deep-orange: #ff5722;
+  --deep-orange-1: #fbe9e7;
+  --deep-orange-2: #ffccbc;
+  --deep-orange-3: #ffab91;
+  --deep-orange-4: #ff8a65;
+  --deep-orange-5: #ff7043;
+  --deep-orange-6: #ff5722;
+  --deep-orange-7: #f4511e;
+  --deep-orange-8: #e64a19;
+  --deep-orange-9: #d84315;
+  --deep-orange-10: #bf360c;
+  --deep-orange-11: #ff9e80;
+  --deep-orange-12: #ff6e40;
+  --deep-orange-13: #ff3d00;
+  --deep-orange-14: #dd2c00;
+  --brown: #795548;
+  --brown-1: #efebe9;
+  --brown-2: #d7ccc8;
+  --brown-3: #bcaaa4;
+  --brown-4: #a1887f;
+  --brown-5: #8d6e63;
+  --brown-6: #795548;
+  --brown-7: #6d4c41;
+  --brown-8: #5d4037;
+  --brown-9: #4e342e;
+  --brown-10: #3e2723;
+  --brown-11: #d7ccc8;
+  --brown-12: #bcaaa4;
+  --brown-13: #8d6e63;
+  --brown-14: #5d4037;
+  --grey: #9e9e9e;
+  --grey-1: #fafafa;
+  --grey-2: #f5f5f5;
+  --grey-3: #eeeeee;
+  --grey-4: #e0e0e0;
+  --grey-5: #bdbdbd;
+  --grey-6: #9e9e9e;
+  --grey-7: #757575;
+  --grey-8: #616161;
+  --grey-9: #424242;
+  --grey-10: #212121;
+  --grey-11: #f5f5f5;
+  --grey-12: #eeeeee;
+  --grey-13: #bdbdbd;
+  --grey-14: #616161;
+  --blue-grey: #607d8b;
+  --blue-grey-1: #eceff1;
+  --blue-grey-2: #cfd8dc;
+  --blue-grey-3: #b0bec5;
+  --blue-grey-4: #90a4ae;
+  --blue-grey-5: #78909c;
+  --blue-grey-6: #607d8b;
+  --blue-grey-7: #546e7a;
+  --blue-grey-8: #455a64;
+  --blue-grey-9: #37474f;
+  --blue-grey-10: #263238;
+  --blue-grey-11: #cfd8dc;
+  --blue-grey-12: #b0bec5;
+  --blue-grey-13: #78909c;
+  --blue-grey-14: #455a64;
+}
+body.q-body--prevent-scroll {
+  position: initial !important;
+}
 #wpcontent {
   padding: 20px;
 …
 .gap-5 {
   gap: 5px;
+}
+.gap-10 {
+  gap: 10px;
+}
 …
+}
+#adminmenu #toplevel_page_vtables .wp-menu-image img {
+  opacity: 1;
+}
+.q-table td,
+.q-table th {
+  white-space: normal;
+  word-wrap: break-word;
+}
+#q-notify .row {
+  padding-top: 0;
+  padding-bottom: 0;
+}
+/* ===== TheTable styles ===== */
+.q-item__section--avatar {
+  min-width: unset;
+}
+.settings-open {
+  margin-right: 325px;
+}
+.fullscreen .q-table__top {
+  padding: 0;
+}
+.fullscreen .q-table__top .vtable__top {
+  padding: 12px 16px;
+}
+.fullscreen.q-table--dense .vtable__top {
+  padding: 8px 16px;
+}
+.cell-value {
+  display: block;
+  white-space: initial;
+  width: inherit;
+}
+.q-table--cell-separator .q-table__top {
+  border-bottom: none !important;
+}
+.q-table--cell-separator .q-table__top .vtable__top {
+  border-bottom: 1px solid rgba(0, 0, 0, 0.12);
+}
+.vtable {
+  margin: 10px 0;
+}
+.vtable .q-table__bottom {
+  padding: 0;
+}
+.vtable .q-table__bottom > div {
+  border-radius: 0 0 4px 4px;
+  padding: 4px 10px 4px 10px;
+  min-height: inherit;
+}
+.vtable .q-table__bottom--nodata {
+  padding-left: 10px;
+  padding-right: 10px;
+}
+.vtable .q-field__bottom {
+  padding-left: 0;
+  padding-right: 0;
+  position: absolute;
+  background: #fff;
+}
+.vtable .q-table__top {
+  padding: 0;
+  overflow: hidden;
+}
+.vtable .q-table__top > div {
+  padding: 12px 16px;
+  min-height: inherit;
+}
+.vtable .q-table--dense .q-table__top {
+  padding: 0;
+  overflow: hidden;
+}
+.vtable .q-table--dense .q-table__top > div {
+  padding: 8px 16px;
+  min-height: inherit;
+}
+.edit-icon {
+  position: absolute;
+}
+.q-td .edit-icon {
+  top: -8px;
+}
+/* Quasar makes body cells positioned, header cells not — the edit icon needs
+   the th as its containing block. */
+.q-table thead th {
+  position: relative;
+}
+.q-table thead th .edit-icon {
+  top: -6px;
+}
+.vtable__top h1 {
+  display: inline-block;
+  position: relative;
+}
+.vtable__top h1 .edit-icon {
+  top: -10px;
+  right: -45px;
+}
+.vtable__top:hover .edit-icon,
+.q-td:hover .edit-icon,
+.q-table thead th:hover .edit-icon,
+.q-item__section:hover .edit-icon {
+  display: block !important;
+}
+.admin-bar-presented-on-fullscreen {
+  margin-top: 30px;
+  margin-left: 160px;
+}
+.fullscreen-btn {
+  height: 40px;
+  width: 40px;
+}
+.v-enter-active,
+.v-leave-active {
+  transition: opacity 0.5s ease;
+}
+.v-enter-from,
+.v-leave-to {
+  opacity: 0;
+}
+.q-table th.sortable {
+  cursor: pointer;
+  min-width: 116px;
+}
+.cell-raw-html > * {
+  cursor: pointer;
+}
+.q-table__container {
+  margin: 2px;
+}
+.pre-wrap {
+  white-space: pre-wrap;
+}
+.flex-no-wrap {
+  flex-wrap: nowrap;
+}

vtables/trunk/quasar.config.js

-              r3036822
+              r3754379
       vueRouterMode: 'hash', // available values: 'hash', 'history'
+      // vueRouterBase,
+      // Empty on purpose: with the hash router the base only pollutes generated
+      // hrefs, and leaving it unset would make Quasar derive it from publicPath
+      // below — i.e. bake the placeholder token into the router too.
+      vueRouterBase: '',
       // vueDevtools,
       // vueOptionsAPI: false,
 …
       // rebuildCache: true, // rebuilds Vite/linter/etc cache on startup
+      publicPath: ctx.dev ? '/' : './wp-content/plugins/vtables/dist/spa',
+      // Placeholder, NOT a real path. Vite 2.9 inlines the public path as a
+      // string literal into the bundle (lazy-chunk base, CSS url()), so a real
+      // path here would hardcode the install location and break sites where WP
+      // lives in a subdirectory, wp-content is relocated, or the plugin folder
+      // is renamed. scripts/patch-asset-base.mjs rewrites this token after the
+      // build into a runtime-resolved base — see the script's header.
+      publicPath: ctx.dev ? '/' : '/__vtables_base__/',
       // analyze: true,
       // env: {},
 …
       // https: true
       open: false, // opens browser window automatically
+      port: 9001,
+      // Must match VTABLES_BASE_URL in env.php. Kept apart from vTables Pro's
+      // 9001: Quasar silently moves to the next free port when this one is
+      // taken, and WordPress would then load the other plugin's dev bundle.
+      port: 9000,
+      proxy: {
+        '/wp-json': {
+          target: 'http://localhost:8000',
+          changeOrigin: true,
+        },
+      },
     },
     // https://v2.quasar.dev/quasar-cli-vite/quasar-config-js#framework
     framework: {
+      config: {},
+      config: {
+        notify: {
+          position: 'bottom-right',
+        },
+      },
       // iconSet: 'material-icons', // Quasar icon set
 …
     // https://v2.quasar.dev/quasar-cli-vite/quasar-config-js#sourcefiles
     sourceFiles: {
       rootComponent: 'src/domains/general/ui/App.vue',
       store: 'src/domains/general/store/index',
       router: 'src/domains/general/router/index',
+      // rootComponent: 'src/domains/general/ui/App.vue',
+      // store: 'src/domains/general/store/index',
+      // router: 'src/domains/general/router/index',
       //   registerServiceWorker: 'src-pwa/register-service-worker',
       //   serviceWorker: 'src-pwa/custom-service-worker',

vtables/trunk/readme.txt

-              r3576934
+              r3754379
 === Data table plugin: Spreadsheets | Google Sheets | WooCommerce product tables ===
+=== vTables – Data Tables from CSV, Excel and JSON ===
 Contributors: iamvs
-Author URI: https://iamvs.com/
-Plugin URI: https://vtables.pro/
 Donate link: https://vtables.pro/
 Tags: data table, spreadsheet, google sheets, woocommerce-table, product-table
 Requires at least: 4.7
 Tested up to: 7.0
+Stable tag: 0.2.1
+Requires PHP: 7.0
+Tags: table, data table, spreadsheet, csv, excel
+Requires at least: 6.0
+Tested up to: 7.1
+Requires PHP: 7.4
+Stable tag: 0.3
 License: GPLv3
 License URI: https://www.gnu.org/licenses/gpl-3.0.html
 WordPress data table plugin: spreadsheets, google sheets, WooCommerce product tables. Transform your data into stunning data tables.
+Build interactive data tables from CSV, Excel and JSON files, or from scratch, and embed them anywhere with a shortcode.
 == Description ==
+[Website](https://vtables.pro/) | [Video Guide](https://www.youtube.com/watch?v=RRMnKfhCut8) | [User Guide](https://vtables.pro/documentation) | [FAQ](https://vtables.pro/faq) | [Developer](https://iamvs.com)
+vTables turns spreadsheets into clean, responsive tables for your site. Import a file or start from an empty grid, edit it right in the WordPress admin, style it, and place it on any page or post with a shortcode.
 Unlock Google Sheets and WooCommerce integrations with **vTables Pro Add-on** – [Download for FREE](https://vtables.pro)
+[Website](https://vtables.pro/) | [User Guide](https://vtables.pro/documentation) | [FAQ](https://vtables.pro/faq)
+Discover the ultimate solution for transforming your WordPress site's data presentation with our spreadsheet plugin. Seamlessly convert spreadsheets, Google Sheets, and WooCommerce products into captivating tables that captivate your audience effortlessly.
+= Features =
+https://www.youtube.com/watch?v=RRMnKfhCut8
+* **Import** CSV, JSON, XLS and XLSX files (large files are uploaded in chunks and imported in the background).
+* **Build tables from scratch**: set the number of columns and rows, then fill the cells in.
+* **Edit in place**: double-click any cell or header to edit it; add, rename and delete rows and columns from the right-click menu.
+* **Unlimited tables**, and as many tables per page as you like.
+* **Shortcode embed**: `[vtables id="1"]` shows the table; `[vtables id="1" row="2" column="email"]` prints a single cell value inside your text.
+* **Smart cells**: image URLs become thumbnails, links become clickable, `<button href="…">Label</button>` becomes a button, and basic HTML (links, images, line breaks) is rendered safely.
+* **Style**: colors for the title bar, header, body, pagination bar, links and buttons; dense and flat layouts; row/column separators; sticky header; table height and maximum width.
+* **Pagination** for large tables: rows are loaded page by page from the database, so tables with many thousands of rows stay fast.
+* **Export** any table as CSV, JSON or XLSX.
+* Works with the block editor, classic editor and page builders that accept shortcodes (Divi, Elementor, WPBakery, …).
+* Translated into English, German, Spanish, French, Hindi, Italian, Norwegian, Portuguese, Russian, Swedish, Turkish and Chinese.
 === Data sources ===
+= vTables Pro =
+. CSV spreadsheet;
+. JSON data;
+. Google Sheets;
+. WooCommerce products.
+[vTables Pro](https://vtables.pro) is a separate, paid add-on that runs on top of this plugin and uses the same tables. It adds:
+=== Features ===
+* Data sources: Google Sheets, external CSV/JSON URLs and WooCommerce product tables, with automatic sync.
+* Visitor tools: search, sorting and row filters.
+* Layout: column visibility, sticky first/last column, column widths, grouped headers, responsive card view, rows per page, custom CSS.
+* More cell formats: video, PDF, audio, Google Maps, star rating, progress bar and JSON.
+. Unlimited Tables:
+Create and customize data tables to your heart's content. There are no limits here – whether you're managing a small business or curating content, vTables empowers you to showcase your data in unlimited ways. 🌟
+This plugin is fully functional on its own and never requires Pro.
+. Unlimited Tables per Page:
+Break free from layout constraints and seamlessly display multiple tables on a single page. With vTables, your users can explore a wealth of information without any hindrance. 🚀
+= Source code and third-party libraries =
+. Extract specific values from a sheet
+Effortlessly retrieve specific cell values from your spreadsheets using custom attributes within a shortcode. For example, [vtables id="1" row="1" column="email"] lets you grab exactly what you need from your data. 💡
+The admin screen and the embedded table are a Vue application. Its complete, unminified source ships with the plugin in the `src/` folder, together with the build setup (`package.json`, `quasar.config.js`, `scripts/`). To rebuild: `npm ci && npm run build` (PHP dependencies: `composer install --no-dev`).
+. Google Sheets Integration
+Keep your WordPress data tables in sync with Google Sheets effortlessly. With just a click, your tables reflect any updates made to your spreadsheet. 🎶
+*available in **vTables Pro Add-on** – [Download for FREE](https://vtables.pro)*
+Bundled libraries, all GPL-compatible:
+. WooCommerce Integration
+Enhance your e-commerce strategy by seamlessly managing and displaying product information. Connect your WooCommerce shop with vTables for a cohesive user experience. 🌟
+*available in **vTables Pro Add-on** – [Download for FREE](https://vtables.pro)*
+* Vue, Vue Router, Pinia, Vue I18n (MIT)
+* Quasar Framework (MIT) and Material Icons (Apache License 2.0)
+* Axios, Lodash, Papa Parse, VueUse, Vuelidate (MIT)
+* SimpleXLSX and SimpleXLS by Sergey Shuchkin (MIT)
+. Styling
+Customize your data tables to match your site's design seamlessly. With extended styling options, choose color schemes, and more to create visually stunning tables. 🎨
+vTables does not track users and makes no requests to external services. The only external links in the admin are to vtables.pro, and they open only when you click them.
+. Export
+Prepare reports, share insights, or collaborate with your team by seamlessly exporting tables in various formats such as CSV and JSON. 🔗
+*available in **vTables Pro Add-on** – [Download for FREE](https://vtables.pro)*
+== Installation ==
+. Premium Features:
+Unlock exclusive premium features like sorting, search, sticky columns, and more to enhance user interaction.
+*available for [PREMIUM](https://vtables.pro/pricing/) plans only*
+. vTables seamlessly integrates with leading site builders such as Divi, Elementor, and WPBakery.
+Whether you're utilizing Divi table, Elementor table, or WPBakery table, vTables seamlessly integrates with leading site builders. Incorporate tables, CSV spreadsheets, and Google Sheets effortlessly into your site's design.
+== Why Choose vTables (PRO): Spreadsheets, Google Sheets, WooCommerce product tables ==
+- Simplifies complex data management tasks.
+- Boosts productivity with efficient spreadsheet tools.
+- Perfect for store owners looking to streamline their operations.
+- Import and export product data using CSV and JSON.
+- Seamless integration with Google Sheets.
+- Seamless integration with WooCommerce.
+- Create and manage WooCommerce product tables effortlessly.
+- Supports multiple spreadsheet formats and customization options.
+- User-friendly interface with drag-and-drop functionality.
+== Requirements ==
+– WordPress version 6.4 or higher
+– PHP version 8.0 or higher
+– Browser compatibility: Edge >= 88, Firefox >= 78, Chrome >= 87, Safari >= 13.1
+== Notice ==
+If you're using a caching plugin, make sure to exclude the vTables plugin from caching. In your cache plugin settings, locate the **"Do Not Cache URIs"** field and add **"vtables"** to the list. After making this change, clear the cache to ensure the new settings take effect.
+If you've made a change and don't see updates on the page, try re-saving it to trigger a page-level cache reset, or clear the cache manually through your caching plugin.
+. In the WordPress admin go to **Plugins → Add New**, search for **vTables**, and click **Install Now**, then **Activate**. (Or upload the `vtables` folder to `/wp-content/plugins/` and activate it on the Plugins screen.)
+. Open **vTables** in the admin menu and click **Add table**.
+. Choose **Create** to start from an empty grid, or **Upload** to import a CSV, JSON, XLS or XLSX file.
+. Copy the table's shortcode (for example `[vtables id="1"]`) and paste it into any page or post.
 == Frequently Asked Questions ==
 = Can users without a technical background or development experience use the vTables? =
+= How do I show a table on a page? =
 vTables is specifically designed to be the most beginner-friendly and non-technical WordPress table plugin available. Our documentation and user manuals are meticulously crafted to ensure that even individuals with limited technical proficiency can harness the full potential of our table builder effortlessly.
+Every table has a shortcode, shown in the table list and on the table's page, like `[vtables id="1"]`. Paste it into a Shortcode block (or directly into the classic editor or your page builder).
 = Who is vTables plugin suitable for? =
+= How do I print a single value from a table? =
 vTables – is a [WordPress table plugin](https://vtables.pro) that caters to a broad audience, from beginners to experts. The user-friendly interface empowers anyone to comfortably create and customize dynamic tables without the need for coding skills.
+Add `row` and `column`: `[vtables id="1" row="2" column="email"]` prints the value of the `email` column in the second row. Column names are case-insensitive and spaces become underscores.
 = Is it possible to import tables from other plugins into vTables? =
+= Can I upload an Excel file? =
 Certainly, you can seamlessly import tables from other plugins into vTables by exporting them in CSV format.
+Yes. XLSX and XLS files are imported directly; the first row becomes the header.
 = How can vTables handle long tables with a substantial amount of data? =
+= Can I put images, links and buttons in cells? =
 Managing extensive tables with large datasets is made simple with vTables. You can utilize features such as Pagination to break down tables into segments. Additionally, the Search/Filter option enables quick retrieval of specific information from even the most colossal table datasets.
+Yes. Paste an image URL (ending in .jpg, .png, .gif, .webp, .svg, …) to show a thumbnail — clicking it opens the full image — or any http(s) link to show a clickable link. For a button, use `<button href="https://example.com">Buy now</button>`.
 = Can I import tables from Google Sheet or Google Drive? =
+= I updated from vTables 0.2.x. What changed? =
 Yes, vTables allows you to import tables from Google Sheet / Google Drive with the added functionality provided by the **vTables Pro Add-on** – [Download for FREE](https://vtables.pro).
+Your tables, their data and their shortcodes keep working, and the update runs automatically in the background:
+= How to upload an EXCEL file? =
+* Table rows are moved into a dedicated database table, a few tables at a time, so large tables load page by page.
+* Some settings that were free in 0.2.x — search, sorting, sticky columns, custom CSS and rows per page — are now part of vTables Pro. Your saved values are kept untouched; they apply again if you install vTables Pro. Until then the table shows with the free options, and a one-time notice lists how many tables are affected.
+* Columns you had hidden stay hidden.
+To upload an EXCEL file, save it as a CSV. To do this, open your spreadsheet in EXCEL, click "File" -> "Save As," and select the "CSV" format. After that, you will be able to upload and convert this file into a table.
+= Does vTables work with caching plugins? =
+= Can I upload images to table cells? =
+Yes. The embedded table is served from its own URL (`/vtables-embed/{id}/`) that tells caching and optimisation plugins not to cache or rewrite it. If a page still shows old content after an update, clear your page cache once.
+You can simply paste a URL (it should contain an image extension) to an image  into the desired cell, and the plugin will do the rest.
+You can also turn on the "Image Popup" option in the settings to show an image in a popup when clicked.
+= What is the relationship with vTables Pro? =
 Currently available with **vTables Pro Add-on** – [Download for FREE](https://vtables.pro).
+vTables Pro is an optional paid add-on. It needs this plugin to be active and works on the same tables, so you can install it at any time without re-creating anything — and if you remove it later, your file-based tables keep working here.
 = Can I add buttons to table cells? =
+= Is my data deleted when I delete the plugin? =
+Yes, you can simply paste a link into the desired cell, and the plugin will do the rest. You can also convert your links into buttons. To do this, simply switch the toggle "Links as" to the "Button" option. [available with PREMIUM plans](https://vtables.pro/pricing)
+= Can I connect Google Sheets to the plugin? =
+You can easily connect Google Sheets with your tables.
+Available with **vTables Pro Add-on** – [Download for FREE](https://vtables.pro).
+= Can I import a spreadsheet from Google Sheets? =
+Yes, you can easily import Google Sheets into the plugin.
+Available with **vTables Pro Add-on** – [Download for FREE](https://vtables.pro).
+= Can I create a WooCommerce product table? =
+Sure, you can create a product table in just a few clicks. On the "Tables" page, click the "Add Table" button, select "Woo Products," name your table, select the desired category/categories with products, and click "Import."
+Available with **vTables Pro Add-on** – [Download for FREE](https://vtables.pro).
+= Can I create a WooCommerce product table with external products? =
+Sure, you can create a product table with external products in just a few clicks. On the "Tables" page, click the "Add Table" button, select "Woo Products," name your table, select the desired category/categories with products, and click "Import." Alternatively, if you haven't set up WooCommerce, you can create a spreadsheet or Google Sheet with external links and import that sheet.
+Available with **vTables Pro Add-on** – [Download for FREE](https://vtables.pro).
+No. Deleting the plugin removes its settings, but keeps your tables, so reinstalling brings them back. To delete the tables as well, add `define( 'VTABLES_REMOVE_ALL_DATA', true );` to wp-config.php before deleting the plugin (this is ignored while vTables Pro is installed, since it uses the same tables).
 = Can I suggest a feature? =
 Sure, please use the contact form on the official website.
+Sure — please use the contact form on [vtables.pro](https://vtables.pro).
 == Screenshots ==
+. "Dashboard"
+. "CSV spreadsheet"
+. "Google Sheets"
+. "WooCommerce product table"
+. "Table settings"
+. Tables list
+. A table imported from a CSV file
+. Google Sheets table (vTables Pro)
+. WooCommerce product table (vTables Pro)
+. Table settings
+== Upgrade Notice ==
+= 3.0.0 =
+Rebuilt admin and table viewer, faster pagination, XLS/XLSX import and security hardening. Tables and shortcodes keep working; search, sorting, sticky columns, custom CSS and rows per page move to vTables Pro, and their saved values are kept.
 == Changelog ==
+= 3.0.0 =
+* New admin and table viewer, with in-place editing of cells, headers, rows and columns.
+* New: XLS and XLSX import; chunked background import for large files.
+* New: tables are stored row by row and paged from the database; existing tables are migrated in the background.
+* New: export as XLSX.
+* New: the embedded table is served by WordPress (`/vtables-embed/{id}/`) and opts out of page caching and script optimisation.
+* Security: all admin actions require a nonce and the `manage_options` capability; the public endpoints only read single tables; SQL ordering is allowlisted; database errors are no longer shown to visitors; uploads in progress are stored in a protected folder.
+* Changed: search, sorting, sticky columns, custom CSS and rows per page are now vTables Pro features; saved values are kept.
+* Removed: the `vtables/v1` REST routes (replaced by admin-ajax actions).
 = 0.2.1 =

vtables/trunk/src/boot/i18n.ts

-              r3576926
+              r3754379
 import messages from 'src/i18n';
+import { getSysInfo } from 'boot/wpapi';
 export type MessageLanguages = keyof typeof messages;
 // Type-define 'en-US' as the master schema for the resource
 export type MessageSchema = typeof messages['en-US'];
+export type MessageSchema = (typeof messages)['en-US'];
 // See https://vue-i18n.intlify.dev/guide/advanced/typescript.html#global-resource-schema-type-definition
 …
 /* eslint-enable @typescript-eslint/no-empty-interface */
+function resolveLocale(): MessageLanguages {
+  const wpLocale: string = getSysInfo().locale ?? '';
+  if (wpLocale.startsWith('es')) return 'es';
+  if (wpLocale.startsWith('de')) return 'de';
+  if (wpLocale.startsWith('fr')) return 'fr';
+  if (wpLocale.startsWith('it')) return 'it';
+  if (wpLocale.startsWith('ru')) return 'ru';
+  if (wpLocale.startsWith('pt')) return 'pt';
+  if (wpLocale.startsWith('hi')) return 'hi';
+  if (wpLocale.startsWith('nb')) return 'nb';
+  if (wpLocale.startsWith('sv')) return 'sv';
+  if (wpLocale.startsWith('tr')) return 'tr';
+  if (wpLocale === 'zh_CN') return 'zh-CN';
+  if (wpLocale.startsWith('zh')) return 'zh-HK';
+  return 'en-US';
+}
 export default boot(({ app }) => {
   const i18n = createI18n({
+    locale: 'en-US',
+    locale: resolveLocale(),
+    fallbackLocale: 'en-US',
     legacy: false,
     messages,

vtables/trunk/src/boot/services.ts

r3576926	r3754379
1		import { api } from 'src/~~domains/general/~~services';
	1	import { api } from 'src/services';
2	2
3	3	export { api };

vtables/trunk/src/boot/wpapi.ts

-              r3576926
+              r3754379
+import WP from 'wpapi';
+/**
+ * WordPress-provided runtime values, localized as `vtables_sys_info`:
+ * - admin screen: wp_localize_script in LoadAssets::vtables_enqueue_assets_admin
+ *   (ajaxurl, nonce, upload limit, locale);
+ * - public embed document: printed inline by Embed::render_document
+ *   (ajaxurl, locale — never a nonce).
+ * The SPA reads its own window first; the parent window is a fallback for
+ * embeds cached before the values were printed into the document.
+ */
+export type SysInfo = {
+  ajaxurl?: string;
+  nonce?: string;
+  max_upload_size?: number | string;
+  locale?: string;
+  plain_links?: boolean | string;
+  pro_url?: string;
+};
+const windowObj: any = window;
+export function getSysInfo(): SysInfo {
+  type WithSysInfo = { vtables_sys_info?: SysInfo };
+  const own = (window as unknown as WithSysInfo).vtables_sys_info;
+  if (own) return own;
+const baseUrl = windowObj.WP_API_Settings?.base_url || '/wp-json/';
+  try {
+    return (window.parent as unknown as WithSysInfo)?.vtables_sys_info ?? {};
+  } catch {
+    // Cross-origin parent: nothing to read.
+    return {};
+  }
+}
+const wpapi = new WP({
+  endpoint: baseUrl,
+  nonce: windowObj.WP_API_Settings.nonce,
+});
+function getAjaxUrl(): string {
+  return getSysInfo().ajaxurl || '/wp-admin/admin-ajax.php';
+}
+wpapi.vtables = wpapi.registerRoute('vtables/v1', '/tables/(?P<id>\\d+)');
+function getSecurity(): string {
+  return getSysInfo().nonce || '';
+}
+wpapi.vtables_source = wpapi.registerRoute(
+  'vtables/v1',
+  '/source/(?P<id>\\d+)'
+);
+function getUploadMaxFilesize(): number {
+  const size = Number(getSysInfo().max_upload_size);
+  // Conservative fallback: 2 MB
+  return size > 0 ? size : 2 * 1024 * 1024;
+}
+wpapi.vtables_settings = wpapi.registerRoute(
+  'vtables/v1',
   '/settings/(?P<id>\\d+)'
+);
+/** Where the "Pro" teasers link to. */
+function getProUrl(): string {
+  return getSysInfo().pro_url || 'https://vtables.pro';
+}
 wpapi.license = wpapi.registerRoute('vtables/v1', '/license');
+const ajaxUrl = getAjaxUrl();
 export { wpapi, baseUrl };
+export { ajaxUrl, getSecurity, getUploadMaxFilesize, getProUrl };

vtables/trunk/src/css/app.scss

-              r3576926
+              r3754379
+@import url('/public/css/vtables.css');
+.material-icons {
+  font-family: Material Icons;
+  font-weight: 400;
+  font-style: normal;
+  display: inline-block;
+  line-height: 1;
+  text-transform: none;
+  letter-spacing: normal;
+  word-wrap: normal;
+  white-space: nowrap;
+  direction: ltr;
+  -webkit-font-smoothing: antialiased;
+  text-rendering: optimizeLegibility;
+  -moz-osx-font-smoothing: grayscale;
+  font-feature-settings: 'liga';
+}

vtables/trunk/src/i18n/en-US/index.ts

-              r3576926
+              r3754379
   abort_upload: 'Abort Upload',
   actions: 'Actions',
+  activate: 'Activate',
   active: 'Active',
+  inactive: 'Inactive',
+  and: 'and',
+  add_column: 'Add column',
   add_column_after: 'Add column after',
   add_column_before: 'Add column before',
+  add_condition: 'Add condition',
+  add_group: 'Add group',
+  add_row: 'Add row',
   add_row_after: 'Add row after',
   add_row_before: 'Add row before',
+  add_subgroup: 'Add subgroup',
   add_table: 'Add table',
+  add_to_cart: 'Add to cart',
+  add_to_cart_button_label: 'Add to cart button label',
   add_top_row: 'Add top row',
+  appearence: 'Appearence',
+  applied: 'Applied',
+  apply: 'Apply',
+  apply_changes: 'Apply changes',
+  ascending: 'Ascending',
+  auto_sync: 'Auto Sync',
+  auto_sync_interval: 'Auto-sync interval',
+  manual_sync: 'Manual sync',
   back_to_dashboard: 'Back to dashboard',
   background_color: 'Background color',
   baseline: 'Baseline',
   binary_sorting: 'Binary sorting',
+  body: 'Body',
   bordered: 'Bordered',
   borderless: 'Borderless',
 …
   button_text: 'Button text',
   button_text_color: 'Button text color',
+  buy_now: 'Buy now',
+  buy_now_mode: 'Buy now mode',
   cancel: 'Cancel',
   card_css_class: 'Card CSS class',
 …
   clear: 'Clear',
   clear_all: 'Clear All',
+  clear_group_tree: 'Clear tree',
+  close: 'Close',
   color: 'Color',
   column: 'Column',
+  column_groups: 'Col. groups',
+  column_name: 'Column Name',
   columns: 'Columns',
   columns_max_width: 'Columns max width',
+  columns_min_width: 'Columns min width',
+  columns_desktop: 'Columns (desktop)',
+  columns_mobile: 'Columns (mobile)',
+  columns_tablet: 'Columns (tablet)',
   confirm: 'Confirm',
+  connected: 'Connected',
   content: 'Content',
   copied: 'Copied',
   copy: 'Copy',
+  create: 'Create',
+  create_table: 'Create table',
   custom_css: 'Custom CSS',
+  daily: 'Daily',
   dark: 'Dark',
   date: 'Date',
+  deactivate: 'Deactivate',
+  descending: 'Descending',
+  desktop: 'Desktop',
   delete: 'Delete',
   delete_column: 'Delete column',
+  delete_group: 'Delete group',
   delete_row: 'Delete row',
   dense: 'Dense',
   dense_mode: 'Dense mode',
+  dimensions: 'Dimensions',
+  dismiss: 'Dismiss',
   done: 'Done',
+  configure_indexes: 'Configure indexed columns',
+  configure_columns: 'Configure columns',
+  create_without_indexes: 'Create without indexes',
+  index_column: 'Index',
+  data_type: 'Data type',
+  type_text: 'Text',
+  type_number: 'Number',
+  type_date: 'Date',
+  type_boolean: 'Boolean',
+  start_import: 'Start import',
+  skip: 'Skip',
   download: 'Download',
-  dimensions: 'Dimensions',
   edit: 'Edit',
   edit_table: 'Edit table',
+  enable_column_groups: 'Enable column groups',
+  every_1_minute: 'Every 1 minute',
+  every_5_minutes: 'Every 5 minutes',
+  every_15_minutes: 'Every 15 minutes',
+  every_30_minutes: 'Every 30 minutes',
+  every_30_seconds: 'Every 30 seconds',
+  every_hour: 'Every hour',
+  exp_date: 'Exp. date',
+  expire_soon: 'Expire soon',
+  expired: 'Expired',
   export: 'Export',
+  external: 'External',
   failed: 'Action failed',
   fetch: 'Fetch',
 …
   filesize: 'File Size',
   filled: 'Filled',
+  filter: 'Filter',
+  filter_column: 'Column',
+  filter_logic: 'Filter logic',
+  filter_operator: 'Operator',
+  filter_value: 'Value',
   flat: 'Flat',
   format: 'Format',
 …
   fullscreen_mode: 'Fullscreen mode (applies for Table view only)',
   general: 'General',
+  get_license: 'Get License',
+  get_new_license: 'Get new license',
+  get_plan: 'Get Plan',
+  go_to_cart: 'Go to cart',
+  google_sheets_api_key: 'Google Sheets API Key',
   grid: 'Grid',
   grid_header: 'Grid header',
+  group_name: 'Group name',
+  group_tree: 'Group tree',
   header: 'Header',
   header_background_color: 'Header background',
   header_css_class: 'Header CSS class',
+  header_groups: 'Header Groups',
   header_text_color: 'Header text color',
+  hidden: 'Hidden',
   hide: 'Hide',
   hide_bottom: 'Hide bottom',
   hide_header: 'Hide header',
   hide_pagination: 'Hide pagination',
+  hide_settings: 'Hide settings',
   hide_title: 'Hide title',
   horizontal: 'Horizontal',
+  hyperlink_color: 'Hyperlink color',
+  hyperlink_text: 'Hyperlink text',
+  hyperlinks_type: 'Hyperlinks type',
+  i_want_to: 'I want to..',
   image: 'Image',
+  image_height: 'Image height',
+  image_popup: 'Image popup',
+  image_width: 'Image width',
   import: 'Import',
   import_all_products: 'Import all products',
+  i_want_to: 'I want to',
+  import_products_from_categories: 'Import products from categories',
+  in_stock_label: 'In stock label',
+  initialize_from_columns: 'Initialize from columns',
+  json_preview_lines: 'JSON preview lines',
+  license: 'License',
+  lifetime: 'Lifetime',
   link: 'Link',
+  logs: 'Logs',
+  migration_status: 'Migration status',
+  migration_completed: 'Completed',
+  migration_in_progress: 'In progress',
+  link_color: 'Link color',
+  link_text: 'Link text',
+  link_to_cart: 'Link to cart',
+  links_as: 'Links as',
   local: 'Local',
   local_csv_file: 'local CSV file',
   merged_selected_cells: 'Merge selected cells',
+  learn_more: 'Learn more',
+  pro: 'Pro',
+  pro_teaser: {
+    external: 'Import tables from any CSV or JSON URL and keep them in sync automatically.',
+    google_sheets: 'Connect a Google Sheet and keep the table in sync automatically.',
+    woocommerce: 'Build product tables from your WooCommerce catalog, with add to cart.',
+    columns: 'Show or hide columns, pin the first or last column, and set column widths.',
+    column_groups: 'Group columns under shared multi-level headers.',
+    css: 'Add your own CSS and classes to style the table.',
+    filter: 'Filter rows by conditions, for visitors and in the admin.',
+    pagination: 'Choose how many rows each page shows.',
+    view: 'Show the table as responsive cards on desktop, tablet and mobile.',
+    rows: 'Image size, lightbox preview and vertical alignment for cells, plus video, PDF, audio, map, rating, progress and JSON cells.',
+    search: 'Add a search box so visitors can find rows.',
+    sorting: 'Let visitors sort the table by any column.',
+  },
   messages: {
+    available_in_pro_version: 'Available in PRO version',
+    available_in_pro_version_under_advanced_subscription_plan:
+      'Available in PRO version (Advanced subscription)',
+    available_in_pro_version_under_lite_subscription_plan:
+      'Available in PRO version (Lite subscription)',
+    available_in_pro: 'Available in vTables Pro.',
+    table_requires_pro: 'This table uses a vTables Pro data source or row filter. Its data is kept unchanged; it can be opened and shown with vTables Pro.',
+    add_filter_conditions_to_table: 'Filter table rows using custom conditions',
     add_search_field_to_table: 'Add search field to table',
     add_your_first_table: 'Add your first table',
+    adds_link_to_cart_in_the_notifications:
+      'Adds link to cart in the notifications',
     all_selected_tables: 'all selected tables',
     allows_showing_images_in_table_if_it_has_columns_with_images_paths:
 …
     allows_users_open_fullsize_image_in_popup:
       'Allows user to open a full-size image in a popup',
+    and_set_it_in_the: 'and set it in the',
     applies_a_default_border: 'Applies a default border to the component',
     applies_dense_mode: 'Applies a dense mode (applies for Table view only)',
 …
     are_you_sure_you_want_to_reset_your_current_settings:
       'Are you sure you want to reset current settings?',
+    available_for_external_google_sheets_woocommerce:
+      'Sync is available for WooCommerce, Google Sheets, and external URL tables only',
+    available_for_table_view_only: 'Available for Table view only',
+    available_for_woocommerce_tables_only:
+      'Available for WooCommerce tables only',
+    available_in: 'Available in',
+    available_with: 'Available with',
+    cant_extract_sheet_id: "Can't extract sheet ID",
+    categories_not_found: 'Categories not found',
+    category_doesnt_exists_or_empty: "Category doesn't exist or empty",
+    changes_have_been_applied: 'Changes have been applied',
     changes_have_been_saved: 'Changes have been saved',
+    column_groups_summary:
+      '{groups} groups · {depth} levels deep · {assigned} of {total} columns assigned',
     column_mismatch: 'Column mismatch.',
+    confirm_clear_group_tree:
+      'This will permanently remove the entire group hierarchy. This cannot be undone.',
+    confirm_remove_license:
+      'This will remove the license key from this site. You can add it again later.',
     couldnt_parse_file_content: "Couldn't parse file content",
+    custom_css_scoped_to_this_table:
+      "CSS is automatically scoped to this table. Write plain selectors, e.g. .q-table th {'{'} background: #eee; {'}'}",
     css_classes_to_apply_to_card:
       'CSS classes to apply to the card (when in grid mode)',
 …
       "CSS classes to apply to native HTML table element's wrapper (DIV)",
     css_classes_to_apply_to_title: 'CSS classes to apply to the title',
+    current_data_will_be_overwritten:
+      'Current data will be overwritten by data from external source (Google Sheets)',
     data_has_been_synced: 'The data has been synced',
     display_data_as_table_or_grid: 'Display data as a table or grid',
+    drag_and_drop_csv_file_to_upload: 'Drag and Drop a CSV file(s) to upload',
+    dont_have_a_key_yet_get_one_from_the:
+      "Don't have a key yet? Get one from the",
+    drag_and_drop_csv_file_to_upload:
+      'Drag and Drop a CSV, JSON or Excel file(s) to upload',
+    drag_to_reorder: 'Drag to reorder',
+    drop_column_here: 'Drop a column here',
+    external_source_column_name_too_long: 'This source has a column name longer than {max} characters — it does not look like a data file.',
+    external_source_is_not_tabular: 'This URL returns a web page, not a data file. Link directly to a CSV or JSON file.',
+    external_source_too_many_columns: 'This source has {count} columns (limit {max}) — it does not look like a data file.',
+    file_too_large: 'File is too large',
+    file_size_limit_is_50mb: 'Maximum file size is 50 MB',
+    file_size_limit_is_10mb: 'Maximum file size is 10 MB',
+    table_source_unrenderable: 'This table has {count} columns and cannot be displayed. It was most likely imported from a web page instead of a data file — delete it and re-import from a direct CSV or JSON link.',
+    uploading_large_file: 'Uploading large file…',
+    choose_up_to_5_columns_to_index:
+      'Choose up to 5 columns to index for faster sorting, filtering and search. Pick the data type for each so comparisons behave correctly.',
+    enable_column_groups_hint:
+      'Group columns under shared header labels with arbitrary nesting depth.',
+    enable_virtual_scroll:
+      'Enable virtual scrolling to efficiently render large datasets. A fixed table height must be set in the Dimensions tab.',
+    external_source_not_found: 'External source not found',
     field_is_required: 'Field is required',
+    unable_to_configure_indexes:
+      'The table was created, but the indexed columns could not be configured.',
+    must_be_whole_number_between:
+      'Must be a whole number between {min} and {max}',
     file_not_found_or_not_accessible: 'File not found or not accessible',
+    fetched_rows_so_far: 'Fetched {n} rows so far…',
     for_first_sticky_column: 'for first sticky column',
     for_last_sticky_column: 'for last sticky column',
     for_sticky_columns_make_sure_you_set_table_width:
       'For sticky columns make sure you set table width on "Dimensions" tab.',
+      'For sticky columns make sure you set table width on "Dimensions" tab if your table does not have a horizontal scrollbar.',
     for_sticky_header_make_sure_you_set_table_height:
       'For sticky header make sure you set table height on "Dimensions" tab.',
+      'For sticky header make sure you set table height on "Dimensions" tab if your table does not have a vertical scrollbar.',
     fullscreen_mode_available_only_for_table_view:
       'Fullscreen mode available only for Table view',
+    google_api_key_has_been_removed: 'Google Sheets API key has been removed',
+    google_api_key_has_been_saved: 'Google Sheets API key has been saved',
+    google_api_key_is_invalid:
+      'This Google Sheets API key could not be validated',
+    google_api_key_problem_banner:
+      'There is a problem with your Google Sheets API key. Tables connected to Google Sheets may stop syncing.',
+    google_sheets_api_key_hint:
+      'When set, Google Sheets imports, resyncs, and the scheduled auto-sync use the official Google Sheets API instead of the public CSV endpoint.',
+    google_sheets_api_key_invalid_notice:
+      'Your Google Sheets API key is invalid or restricted, so data is fetched through a public endpoint instead — this is not reliable and may return incomplete data.',
+    google_sheets_no_api_key_notice:
+      'Importing and syncing Google Sheets without an API key is not reliable — data is fetched through a public endpoint and may be incomplete or fail to load.',
     how_many_columns_from_left_will_be_sticky:
       'How many columns from left will be sticky',
+    migration_log_hint:
+      'Events recorded while tables created by older plugin versions are moved to the new row storage in the background.',
+    no_migration_events_yet: 'No migration events yet.',
     how_many_rows_from_top_will_be_sticky:
       'How many rows from the top will be sticky',
+    license_has_been_activated: 'License has been activated',
+    license_has_been_deactivated: 'License has been deactivated',
+    license_has_been_removed: 'License has been removed',
+    layout_on_desktop_screens: 'Layout on desktop screens (≥ 1440px)',
+    layout_on_mobile_screens: 'Layout on mobile screens (< 600px)',
+    layout_on_tablet_screens: 'Layout on tablet screens (600px – 1439px)',
     make_first_column_sticky: 'Make first column "sticky"',
     make_header_sticky: 'Make header "sticky"',
     make_last_column_sticky: 'Make last column "sticky"',
+    message_has_been_sent_thank_you: 'Message has been sent! Thank you!',
     minimum_number_of_rows_to_render:
       'Minimum number of rows to render in the virtual list',
+    multiple_upload_available_with_premium_plans:
+      'Multiple upload available with Premium plans',
     only_letters_numbers_dashes_and_underscores_allowed:
       'Only letters, numbers, dashes and underscores allowed',
     paste_a_google_sheet_url: 'Paste a google sheet URL',
+    please_check_the_category: 'Please check the category',
+    please_deactivate_license_before_using_it_on_different_site:
+      'Please deactivate license before using it on different site',
     please_ensure_you_only_use_alphanumeric_characters_dashes_underscores_spaces_and_parantheses_for_filenames:
       'Please ensure you only use alphanumeric characters, dashes, underscores, spaces, and parentheses for filenames.',
+    please_get_and_activate_new_license:
+      'Please get and activate a new license',
+    please_get_license: 'Please get a license',
+    please_make_sure_cart_link_set_in_woocommerce_settings:
+      'Please make sure cart link set in WooCommerce settings',
     please_make_sure_the_columns_align_:
       'Please make sure the columns in new spreadsheet align with the table columns.',
     please_make_sure_the_file_is_valid: 'Please make sure the file is valid',
+    please_make_sure_woocommerce_categories_exist:
+      'Please make sure WooCommerce categories exist',
+    please_make_sure_woocommerce_is_intalled_and_activated:
+      'Please make sure woocommerce is installed and activated',
     please_set_table_height: 'Please set table height',
+    please_try_again_later: 'Please try again later',
+    please_turn_on_enable_ajax_option_in_the_woo_settings:
+      'Please select "Enable AJAX add to cart buttons on archives" option in the WooCommerce settings for a better user experience.',
     please_use_unique_value: 'Please use unique value',
     ratio_of_number_of_rows_after:
 …
     ratio_of_number_of_rows_before:
       'Ratio of number of rows in visible zone to render before it',
+    redirect_to_the_cart_page_after_successful_addition:
+      'Redirect to the cart page after successful addition',
+    review_your_key_in_the: 'Review your key in the',
     select_separators: 'Select separators',
+    set_add_to_cart_button_label: 'Set add-to-cart button label',
+    set_auto_sync_interval:
+      'How often the table data is automatically refreshed from the external source',
+    manual_sync_tooltip:
+      'Immediately update the table with fresh data from its source. Available for WooCommerce, Google Sheets, and external URL tables.',
+    use_google_sheets_tab_for_this_url: 'This is a Google Sheets link — import it from the “Google Sheets” tab.',
+    woocommerce_auto_sync_is_realtime:
+      'WooCommerce tables update in real time as products change; the daily task runs a full index reconciliation',
     set_background_color: 'Set background color',
     set_background_color_for_bottom_section:
 …
     set_button_text: 'Set button text',
     set_button_text_color: 'Set button text color',
+    set_cart_link_text: 'Set link text',
     set_cell_vertical_alignment:
       'Set cell vertical alignment (applies for Table view only)',
     set_column_sort_order: 'Set column sort order',
     set_columns_max_width: 'Set columns max width',
+    set_hyperlink_color: 'Set text color',
+    set_hyperlink_text: 'Set hyperlink text',
+    set_columns_min_width: 'Set columns min width',
+    set_in_stock_label: 'Set in_stock label',
+    set_json_preview_lines:
+      'Set the number of lines shown in JSON cell preview before truncating',
+    set_link_color: 'Set text color',
+    set_link_text: 'Set link text',
+    set_notification_background_color: 'Set notification background color',
+    set_notification_heading: 'Set notification heading',
+    set_notification_message: 'Set notification message',
+    set_notification_text_color: 'Set notification text color',
+    set_notification_timer:
+      'Set notification timer in milliseconds, set -1 to make a notification permanent',
+    set_out_of_stock_label: 'Set out_of_stock label',
     set_pagination_label: 'Set rows per page label',
     set_pagination_options: 'Set pagination options',
+    set_path_to_open_cart: 'Set path to cart in notifications',
     set_records_per_page: 'Set records per page',
+    set_background_color_for_search_field:
+      'Set background color for search field',
     set_search_field_color: 'Set search field color',
     set_search_input_style: 'Set search input style',
+    set_style_of_stock_badge: 'Set style of stock badge',
     set_table_height: 'Set table height (applies for Table view only)',
     set_table_max_width: 'Set table max width (applies for Table view only)',
 …
     settings_have_been_reset: 'Settings have been reset',
     settings_have_been_saved: 'Settings have been saved',
+    show_hyperlinks_in_table_if_it_has_columns_with_hyperlinks:
+      'Show hyperlinks as links/buttons in table if it has column/s with hyperlinks',
+    show_links_in_table_if_it_has_columns_with_links:
+      'Show links as links/buttons in table if it has column/s with links',
+    shows_notification_when_item_added_to_cart:
+      'Shows notification when item added to cart',
     size_in_px_of_sticky_header:
       'Size in pixels of the sticky header (if using one); A correct value will improve scroll precision.',
 …
       'Skip the third state (unsorted) when user toggles column sort direction',
     something_went_wrong: 'Something went wrong..',
+    please_try_again_later: 'Please try again later',
+    start_by_initializing_tree:
+      'Start by initializing the tree from your existing columns, or add a group manually.',
+    table_type_not_available_under_your_plan:
+      "{tableType} tables aren't available under your {plan} plan.",
     table_with_name_already_exists: 'Table with name already exists',
     this_is_supported_only_on_modern_browsers:
       'This is supported only on modern browsers',
+    this_setting_applies_to_table_view_only:
+      'This setting applies to Table view only and has no effect when the table is displayed in Grid mode.',
+    to_add_product_to_cart_please_use_shortcode_on_frontpage:
+      'To add product to cart please use shortcode on front page',
+    trial_ended_sync_disabled:
+      'Your trial has ended. Upgrade to continue syncing.',
+    trial_table_limit_reached:
+      'Trial allows only 1 table. Delete your existing table to create a different one, or upgrade.',
     turn_on_off_sorting: 'Turn ON/OFF sorting for columns',
     unable_to_cancel_changes: 'Unable to cancel changes.',
 …
     unable_to_reset_settings: 'Unable to reset settings',
     unable_to_save_changes: 'Unable to save changes.',
+    unsaved_changes: 'Unsaved changes',
+    unsaved_changes_will_be_lost:
+      'You have unsaved table changes. If you leave this page, they will be lost.',
     use_separator_between_rows_cols_cells:
       'Use a separator between rows, columns or all cells',
     use_to_display_large_number_of_rows:
       'Use to display large number of rows (for non-grid mode only)',
+    message_has_been_sent_thank_you: 'Message has been sent! Thank you!',
+    file_has_been_fetched: 'File has been fetched',
+    external_source_not_found: 'External source not found',
+    cant_extract_sheet_id: "Can't extract sheet ID",
+    license_has_been_activated: 'License has been activated',
+    license_has_been_deactivated: 'License has been deactivated',
+    please_deactivate_license_before_using_it_on_different_site:
+      'Please deactivate license before using it on different site',
+    available_for_table_view_only: 'Available for Table view only',
+    virtual_scroll_slice_ratio_after:
+      'Ratio of extra rows pre-rendered below the visible area. Higher values reduce blank rows when scrolling down.',
+    virtual_scroll_slice_ratio_before:
+      'Ratio of extra rows pre-rendered above the visible area. Higher values reduce blank rows when scrolling up.',
+    virtual_scroll_slice_size:
+      'Number of rows rendered at a time. Increase for smoother scrolling, decrease to improve performance on large datasets.',
+    virtual_scroll_sticky_size_start:
+      'Height in pixels reserved for sticky rows pinned to the top of the virtual list.',
+    woocommerce_cart_link_not_found: 'WooCommerce cart link not found',
+    woocommerce_not_found: 'WooCommerce not found',
+    wraps_product_name_into_a_link: 'Wraps product name into a link',
     your_license_expire_soon: 'Your license expire soon',
+    your_license_is_expired: 'Your license is expired',
+    please_get_and_activate_new_license:
+      'Please get and activate a new license',
+    your_license_is_expired: 'Your license has expired',
+    your_plan_is_expired: 'Your {plan} plan is expired.',
   },
-  valid: 'Valid',
-  expired: 'Expired',
-  expire_soon: 'Expire soon',
-  license: 'License',
-  exp_date: 'Exp. date',
   middle: 'Middle',
+  mobile: 'Mobile',
   modified: 'Modified',
+  more: 'More',
+  new_group: 'New group',
   none: 'None',
+  not_connected: 'Not connected',
   nothing_found: 'Nothing found',
+  notification_background_color: 'Notification bg color',
+  notification_heading: 'Notification heading',
+  notification_message: 'Notification message',
+  notification_text_color: 'Notification text color',
+  notification_timer: 'Notification timer',
+  notifications: 'Notifications',
+  number_of_columns: 'Columns',
+  number_of_rows: 'Rows',
   off: 'Off',
   on: 'On',
   open: 'Open',
+  or: 'Or',
+  open_in_google_sheets: 'Open in Google Sheets',
+  operator_contains: 'Contains',
+  operator_ends_with: 'Ends with',
+  operator_equals: 'Equals',
+  operator_greater_than: 'Greater than',
+  operator_is_empty: 'Is empty',
+  operator_is_not_empty: 'Is not empty',
+  operator_less_than: 'Less than',
+  operator_not_contains: 'Does not contain',
+  operator_not_equals: 'Does not equal',
+  operator_starts_with: 'Starts with',
+  or: 'or',
+  out_of_stock_label: 'Out of stock label',
   outlined: 'Outlined',
+  page: 'Page',
   pagination: 'Pagination',
   pagination_label: 'Pagination label',
   pagination_options: 'Pagination options',
+  path_to_cart: 'Path to cart',
   pick_file: 'Pick File',
+  plan: 'Plan',
+  plans: 'plans',
   preview_mode: 'Preview mode',
+  product_link: 'Product link',
+  products: 'Products',
   records_per_age: 'Records per page',
   remote: 'Remote',
+  refresh: 'Refresh',
   remove: 'Remove',
+  remove_license: 'Remove license',
   remove_selected: 'Remove selected',
   remove_top_row: 'Remove top row',
   remove_uploaded_files: 'Remove Uploaded Files',
+  rename_column: 'Rename column',
+  rename_group: 'Rename group',
+  renew: 'Renew',
   reset: 'Reset',
+  reset_done: 'Reset!',
+  responsive: 'Responsive',
   rows: 'Rows',
   save: 'Save',
 …
   search_field_color: 'Search field color',
   search_input_style: 'Search input style',
+  select_categories: 'Select categories',
   select_color: 'Select color',
+  select_option: 'Select option',
   separator: 'Separator',
   settings: 'Settings',
 …
   show_hide_columns: 'Show/Hide columns',
   show_images: 'Show images',
+  show_more: 'Show more',
+  show_notifications: 'Show notifications',
+  show_settings: 'Show settings',
   sort_order: 'Sort order',
   sorting: 'Sorting',
 …
   square: 'Square',
   standard: 'Standard',
+  status: 'Status',
   sticky_first_column: 'Sticky 1st col.',
   sticky_header: 'Sticky header',
   sticky_last_column: 'Sticky last col.',
+  stock_badge: 'Stock badge',
+  style: 'Style',
   success: 'Action was successful',
   sync: 'Sync',
   table: 'table',
+  table_as: 'table as',
   table_css_class: 'Table CSS class',
   table_height: 'Table height',
-  table_width: 'Table width',
   table_max_width: 'Table max width',
   table_name: 'Table name',
+  table_width: 'Table width',
   tables: 'Tables',
+  tablet: 'Tablet',
   text_color: 'Text color',
-  thumbnail_height: 'Thumbnail height',
-  thumbnail_width: 'Thumbnail width',
   title: 'Title',
   title_css_class: 'Title CSS class',
   top: 'Top',
+  twice_daily: 'Twice a day',
   turn_links_into_buttons: 'Turn links into buttons',
   type: 'Type',
+  unassigned_columns: 'Unassigned columns',
+  upgrade: 'Upgrade',
   upload: 'Upload',
   upload_files: 'Upload Files',
   upload_more: 'Upload More',
   uploaded: 'Uploaded',
+  valid: 'Valid',
+  invalid: 'Invalid',
   vertical: 'Vertical',
   vertical_alignment: 'Vertical alignment',

vtables/trunk/src/i18n/index.ts

-              r3576926
+              r3754379
 import enUS from './en-US';
+import es from './es';
+import de from './de';
+import fr from './fr';
+import hi from './hi';
+import it from './it';
+import nb from './nb';
+import pt from './pt';
+import ru from './ru';
+import sv from './sv';
+import tr from './tr';
+import zhCN from './zh-CN';
+import zhHK from './zh-HK';
 export default {
+  'en-US': enUS
+  'en-US': enUS,
+  es: es,
+  de: de,
+  fr: fr,
+  hi: hi,
+  it: it,
+  nb: nb,
+  pt: pt,
+  ru: ru,
+  sv: sv,
+  tr: tr,
+  'zh-CN': zhCN,
+  'zh-HK': zhHK,
 };

vtables/trunk/uninstall.php

-              r3036822
+              r3754379
 <?php
+if ( ! defined( 'WP_UNINSTALL_PLUGIN' ) ) exit;
+/**
+ * UNINSTALL
+ *
+ * Removes this plugin's options, scheduled events and upload working files.
+ * The tables themselves (wp_vtables, wp_vtables_source) are shared with
+ * vTables Pro and hold the user's content, so they are only dropped on
+ * explicit request — add to wp-config.php before deleting the plugin:
+ *
+ *   define( 'VTABLES_REMOVE_ALL_DATA', true );
+ *
+ * and even then never while vTables Pro is still installed.
+ */
+function vtables_uninstall_site() {
+  global $wpdb;
+  foreach ( array(
+    'vtables_db_version',
+    'vtables_rewrite_version',
+    'vtables_rows_migrated',
+    'vtables_rows_migration_skipped',
+    'vtables_migration_log',
+  ) as $option ) {
+    delete_option( $option );
+  }
+  wp_clear_scheduled_hook( 'vtables_migrate_rows_tick' );
+  // Everything below is shared with vTables Pro (same names), so it stays
+  // while Pro is installed.
+  if ( file_exists( WP_PLUGIN_DIR . '/vtables-pro/vtables-pro.php' ) ) {
+    return;
+  }
+  // Per-table count-cache versions and their transients, plus import sessions.
+  $wpdb->query( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+    "DELETE FROM {$wpdb->options}
+     WHERE option_name LIKE 'vtables\\_count\\_ver\\_%'
+        OR option_name LIKE '\\_transient\\_vtables\\_count\\_%'
+        OR option_name LIKE '\\_transient\\_timeout\\_vtables\\_count\\_%'
+        OR option_name LIKE '\\_transient\\_vtables\\_import\\_%'
+        OR option_name LIKE '\\_transient\\_timeout\\_vtables\\_import\\_%'"
+  );
+  if ( defined( 'VTABLES_REMOVE_ALL_DATA' ) && VTABLES_REMOVE_ALL_DATA ) {
+    $wpdb->query( "DROP TABLE IF EXISTS {$wpdb->prefix}vtables_source" ); // phpcs:ignore WordPress.DB.DirectDatabaseQuery, WordPress.DB.DirectDatabaseQuery.SchemaChange
+    $wpdb->query( "DROP TABLE IF EXISTS {$wpdb->prefix}vtables" ); // phpcs:ignore WordPress.DB.DirectDatabaseQuery, WordPress.DB.DirectDatabaseQuery.SchemaChange
+  }
+}
+function vtables_uninstall_remove_dir( $dir ) {
+  if ( ! is_dir( $dir ) ) {
+    return;
+  }
+  foreach ( array_diff( (array) scandir( $dir ), array( '.', '..' ) ) as $file ) {
+    $path = $dir . $file;
+    if ( is_dir( $path ) ) {
+      vtables_uninstall_remove_dir( $path . '/' );
+    } else {
+      wp_delete_file( $path );
+    }
+  }
+  rmdir( $dir ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_rmdir
+}
+if ( is_multisite() ) {
+  foreach ( get_sites( array( 'fields' => 'ids' ) ) as $vtables_site_id ) {
+    switch_to_blog( $vtables_site_id );
+    vtables_uninstall_site();
+    restore_current_blog();
+  }
+} else {
+  vtables_uninstall_site();
+}
+// Upload working files only (chunks/assembled imports in progress) — never
+// the user's media. Left alone while vTables Pro, which shares it, is installed.
+if ( ! file_exists( WP_PLUGIN_DIR . '/vtables-pro/vtables-pro.php' ) ) {
+  $vtables_upload_info = wp_upload_dir();
+  vtables_uninstall_remove_dir( trailingslashit( $vtables_upload_info['basedir'] ) . 'vtables_uploads/' );
+}

vtables/trunk/vtables.php

-              r3576926
+              r3754379
 /**
+ * Plugin Name: vTables
+ * Description: Create stunning, interactive tables effortlessly. No coding required. The ultimate WordPress plugin, lets you design powerful tables in a few clicks. Transform your data visualization now.
+ * Author: vTables
+ * Author URI: https://vtables.pro
+ * Version: 0.2.1
+ * License: GPLv3
+ * Plugin Name:       vTables – Data Tables from CSV, Excel and JSON
+ * Plugin URI:        https://vtables.pro
+ * Description:       Build interactive data tables from CSV, Excel and JSON files, or from scratch, and embed them anywhere with a shortcode.
+ * Version:           0.3
+ * Requires at least: 6.0
+ * Requires PHP:      7.4
+ * Author:            vTables
+ * Author URI:        https://vtables.pro
+ * License:           GPLv3
+ * License URI:       https://www.gnu.org/licenses/gpl-3.0.html
+ * Text Domain:       vtables
  */
 if ( ! defined( 'ABSPATH' ) ) exit;
+define('VTABLES_URL', plugin_dir_url(__FILE__));
+define('VTABLES_DIR', plugin_dir_path(__FILE__));
+define('VTABLES_VERSION', '0.2.1');
+define( 'VTABLES_VERSION', '0.3' );
+define( 'VTABLES_FILE', __FILE__ );
+define( 'VTABLES_DIR', plugin_dir_path( __FILE__ ) );
+define( 'VTABLES_URL', plugin_dir_url( __FILE__ ) );
+require_once VTABLES_DIR . 'includes/compat.php';
 class vTables {
   public function vtables_boot() {
-    $this->vtables_add_module_to_script();
     $this->vtables_load_classes();
+    $this->vtables_add_upgrade_link();
+    $this->vtables_settings_policy();
+    $this->vtables_maybe_upgrade();
     $this->vtables_register_shortcodes();
     $this->vtables_activate_plugin();
+    $this->vtables_embed();
     $this->vtables_render_menu();
+    $this->vtables_action_links();
     $this->vtables_db_endpoints();
+  }
+  /**
+   * ADD MODULE TO SCRIPT HOOK
+   */
+  public function vtables_add_module_to_script() {
+    add_filter('script_loader_tag', array($this, 'vtables_add_module_to_script_handler'), 10, 3);
+  }
+  /**
+   * ADD MODULE TO SCRIPT HANDLER
+   */
+  function vtables_add_module_to_script_handler($tag, $handle, $src) {
+    if ($handle === 'vtables-script-boot') {
+      $tag = str_replace('<script ', '<script type="module" id="vtables-script-boot" ', $tag);
+    }
+    return $tag;
+    $this->vtables_migrate_rows();
+  }
 …
    */
   public function vtables_load_classes() {
+    require VTABLES_DIR . 'includes/autoload.php';
+  }
+  /**
+   * ADD LINK TO UPGRADE HOOK
+   */
+  public function vtables_add_upgrade_link() {
+    add_filter( 'plugin_action_links_' . plugin_basename(__FILE__), array($this, 'vtables_upgrade_link_handler') );
+  }
+  /**
+   * ADD LINK TO UPGRADE HANDLER
+   */
+  function vtables_upgrade_link_handler( array $links ) {
+    $settings_link = '<b><a target="_blank" href="https://vtables.pro">' . __('Download Pro Add-on for free', 'vtables') . '</a></b>';
+      $links[] = $settings_link;
+    return $links;
+    require_once VTABLES_DIR . 'includes/autoload.php';
+    // SimpleXLSX / SimpleXLS for spreadsheet imports.
+    if ( file_exists( VTABLES_DIR . 'vendor/php/autoload.php' ) ) {
+      require_once VTABLES_DIR . 'vendor/php/autoload.php';
+    }
+  }
+  /**
+   * SETTINGS POLICY
+   * Loaded before the endpoints: save_settings/create_table filter every
+   * settings blob through it.
+   */
+  public function vtables_settings_policy() {
+    include_once VTABLES_DIR . 'includes/settings-policy.php';
+  }
 …
    */
   public function vtables_render_menu() {
     add_action('admin_menu', function () {
       if (!current_user_can('manage_options')) {
+    add_action( 'admin_menu', function () {
+      if ( ! current_user_can( 'manage_options' ) ) {
         return;
+      }
+      global $submenu;
       add_menu_page(
         'vTables',
 …
         'manage_options',
         'vtables',
         array($this, 'vtables_render_admin_page'),
         plugins_url('public/icons/vtables-menu-icon-color.png', __FILE__),
+        array( $this, 'vtables_render_admin_page' ),
+        plugins_url( 'public/icons/vtables-menu-icon-color.png', __FILE__ ),
       );
+    });
+      global $submenu;
+      $submenu['vtables']['tables'] = array( // phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited
+        __( 'Tables', 'vtables' ),
+        'manage_options',
+        'admin.php?page=vtables#/',
+      );
+      // The Logs page only reports the legacy row migration, so it appears
+      // once there is something to report.
+      if ( ! empty( get_option( 'vtables_migration_log' ) ) ) {
+        $submenu['vtables']['logs'] = array( // phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited
+          __( 'Logs', 'vtables' ),
+          'manage_options',
+          'admin.php?page=vtables#/logs',
+        );
+      }
+    } );
+  }
 …
   public function vtables_render_admin_page() {
     $loadAssets = new \vTables\Classes\LoadAssets();
+    $loadAssets->vtables_enqueue_assets();
+    $WP_API = apply_filters('vTables/admin_app_vars', array(
+      'assets_url' => VTABLES_URL . 'dist/assets/',
+      'ajaxurl' => admin_url('admin-ajax.php'),
+      'nonce' => wp_create_nonce( 'wp_rest' ),
+      'base_url' => rest_url(),
+    ));
+    wp_localize_script('vtables-script-boot', 'WP_API_Settings', $WP_API);
+    $loadAssets->vtables_enqueue_assets_admin();
     echo '<div id="q-app"></div>';
+  }
   /**
+   * PLUGIN ACTION LINKS
+   * One "Upgrade" link on the Plugins screen, only while Pro isn't installed.
+   */
+  public function vtables_action_links() {
+    add_filter( 'plugin_action_links_' . plugin_basename( VTABLES_FILE ), function ( $links ) {
+      if ( vtables_is_pro_installed() ) {
+        return $links;
+      }
+      $links[] = '<a href="' . esc_url( 'https://vtables.pro' ) . '" target="_blank" rel="noopener noreferrer">' . esc_html__( 'Upgrade to Pro', 'vtables' ) . '</a>';
+      return $links;
+    } );
+  }
+  /**
    * REGISTER SHORTCODES
    */
   public function vtables_register_shortcodes() {
+    global $shortcode_count;
+    $shortcode_count = 0;
+    // render shortcode
+    function vtables_shortcode_render_handler($atts = []) {
+      global $wpdb;
+      global $shortcode_count;
+      $id = isset($atts['id']) ? intval($atts['id']) : 0;
+      // render specific cell value
+      $row_number = isset($atts['row']) ? intval($atts['row']) : 0;
+      $col_name = isset($atts['column']) ? sanitize_text_field($atts['column']) : '';
+      if ($row_number > 0 && !empty($col_name)) {
+        $col_name_snakecase = strtolower(str_replace(' ', '_', $col_name));
+        $table_name = $wpdb->prefix . 'vtables';
+        $query = $wpdb->prepare("SELECT * FROM $table_name WHERE id = %d", $id);
+        $results = $wpdb->get_results($query);
+        if (empty($results)) {
+          return 'Value not found';
+        }
+        $source = json_decode($results[0]->source);
+        $rows = $source->rows;
+        $row_index = $row_number - 1;
+        if (!isset($rows[$row_index])) {
+          return 'Row not found.';
+        }
+        $cell_value = isset($rows[$row_index]->{$col_name_snakecase}) ? $rows[$row_index]->{$col_name_snakecase} : '';
+        return $cell_value;
+      }
+      // render table
+      $shortcode_count++;
+      ob_start();
+      ?>
+      <div class="vtables-iframe-wrapper">
+        <iframe
+          name="<?php echo esc_attr($shortcode_count); ?>"
+          data-id="<?php echo esc_attr($id); ?>"
+          data-count="<?php echo esc_attr($shortcode_count); ?>"
+          data-baseurl="<?php echo esc_url(rest_url()); ?>"
+          src="<?php echo esc_url(VTABLES_URL . 'includes/shortcode.html'); ?>"
+          style="width: 100%; height: 150px; border: 0 none;"
+        ></iframe>
+      <div>
+      <?php
+      return ob_get_clean();
+    }
+    add_shortcode( 'vtables', 'vtables_shortcode_render_handler' );
+  }
+  /**
+   * ACTIVATE PLUGIN
+   */
+  public function vtables_activate_plugin() {
+    register_activation_hook(__FILE__, function ($newWorkWide) {
+      require_once(VTABLES_DIR . 'includes/Classes/Activator.php');
+      $activator = new \vTables\Classes\Activator();
+      $activator->vtables_migrate_databases($newWorkWide);
+    });
+    add_shortcode( 'vtables', array( $this, 'vtables_shortcode_render_handler' ) );
+  }
+  /**
+   * EMBED DOCUMENT
+   * Serves the [vtables] iframe document from WordPress (/vtables-embed/{id}/),
+   * on the same URL scheme as vTables Pro. See includes/Classes/Embed.php.
+   */
+  public function vtables_embed() {
+    ( new \vTables\Classes\Embed() )->register();
+  }
+  /**
+   * RENDER SPECIFIC VALUE
+   */
+  public function vtables_render_specific_value( $row_number, $col_name, $id ) {
+    global $wpdb;
+    $col_name_snakecase = strtolower( str_replace( ' ', '_', $col_name ) );
+    $row_index = $row_number - 1;
+    $table = vtables_table_meta( $id );
+    if ( $table === null ) {
+      return __( 'Value not found', 'vtables' );
+    }
+    // Pro-only sources, and tables whose saved row filter only Pro applies.
+    if ( vtables_table_requires_pro( $table ) ) {
+      return '';
+    }
+    // Rows live in wp_vtables_source (one record per row, keyed by table_id +
+    // row_index). Tables that still keep their rows inline (0.2.x and older,
+    // not yet migrated) fall through to wp_vtables.source->rows below.
+    $has_migrated_rows = (int) $wpdb->get_var( $wpdb->prepare( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+      "SELECT COUNT(*) FROM {$wpdb->prefix}vtables_source WHERE table_id = %d", $id
+    ) ) > 0;
+    if ( $has_migrated_rows ) {
+      $row_json = $wpdb->get_var( $wpdb->prepare( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+        "SELECT row_json FROM {$wpdb->prefix}vtables_source WHERE table_id = %d AND row_index = %d",
+        $id,
+        $row_index
+      ) );
+      if ( $row_json === null ) {
+        return __( 'Row not found.', 'vtables' );
+      }
+      $row = json_decode( $row_json );
+      return ( is_object( $row ) && isset( $row->{$col_name_snakecase} ) ) ? $row->{$col_name_snakecase} : '';
+    }
+    $legacy_source = $wpdb->get_var( $wpdb->prepare( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
+      "SELECT source FROM {$wpdb->prefix}vtables WHERE id = %d", $id
+    ) );
+    $source = json_decode( (string) $legacy_source );
+    $rows = ( is_object( $source ) && isset( $source->rows ) ) ? $source->rows : array();
+    if ( ! isset( $rows[ $row_index ] ) ) {
+      return __( 'Row not found.', 'vtables' );
+    }
+    return isset( $rows[ $row_index ]->{$col_name_snakecase} ) ? $rows[ $row_index ]->{$col_name_snakecase} : '';
+  }
+  /**
+   * RENDER SHORTCODES
+   */
+  public function vtables_shortcode_render_handler( $atts = array() ) {
+    $atts = is_array( $atts ) ? $atts : array();
+    $id = isset( $atts['id'] ) ? intval( $atts['id'] ) : 0;
+    // render specific cell value
+    $row_number = isset( $atts['row'] ) ? intval( $atts['row'] ) : 0;
+    $col_name = isset( $atts['column'] ) ? sanitize_text_field( $atts['column'] ) : '';
+    if ( $row_number > 0 && ! empty( $col_name ) ) {
+      $value = $this->vtables_render_specific_value( $row_number, $col_name, $id );
+      // json-type cells decode to arrays/objects.
+      if ( ! is_scalar( $value ) ) {
+        $value = wp_json_encode( $value );
+      }
+      // Cell data is untrusted, so escape on output. Allowlist mirrors the
+      // SPA's sanitizeCellHtml (src/composables/useCellRendering.ts) to keep
+      // both render paths in parity.
+      return wp_kses( (string) $value, array(
+        'a'      => array( 'href' => true, 'title' => true, 'target' => true, 'rel' => true, 'class' => true ),
+        'img'    => array( 'src' => true, 'alt' => true, 'title' => true, 'class' => true, 'width' => true, 'height' => true ),
+        'br'     => array(),
+        'button' => array( 'href' => true, 'title' => true, 'target' => true, 'rel' => true, 'class' => true ),
+      ) );
+    }
+    // Tables from Pro-only sources (Google Sheets, external URLs, WooCommerce)
+    // or with a saved row filter render nothing for visitors; admins get a
+    // pointer instead of a blank spot.
+    if ( vtables_table_requires_pro( vtables_table_meta( $id ) ) ) {
+      if ( ! current_user_can( 'manage_options' ) ) {
+        return '';
+      }
+      return '<p class="vtables-requires-pro">' . esc_html(
+        /* translators: %d: table ID. */
+        sprintf( __( 'vTables table #%d needs vTables Pro (Pro data source or row filter), so it is hidden from visitors.', 'vtables' ), $id )
+      ) . '</p>';
+    }
+    $iframe_url = \vTables\Classes\Embed::url( $id );
+    ob_start();
+    ?>
+    <div class="vtables-iframe-wrapper">
+      <iframe
+        src="<?php echo esc_url( $iframe_url ); ?>"
+        title="<?php echo esc_attr__( 'vTables table', 'vtables' ); ?>"
+        loading="lazy"
+        referrerpolicy="same-origin"
+        style="width: 100%; height: 150px; border: 0 none;"
+      ></iframe>
+    </div>
+    <?php
+    return ob_get_clean();
+  }
+  /**
+   * VERSION-GATED UPGRADE
+   * register_activation_hook does not fire when a plugin is updated in place,
+   * and 0.2.x never stored a schema version, so the migrations run on the
+   * first request after an update — gated on the 'vtables_db_version' option,
+   * which makes this a single autoloaded get_option() in the common case.
+   */
+  public function vtables_maybe_upgrade() {
+    if ( get_option( 'vtables_db_version' ) === VTABLES_VERSION ) {
+      return;
+    }
+    $activator = new \vTables\Classes\Activator();
+    $activator->vtables_migrate_databases( false );
+    update_option( 'vtables_db_version', VTABLES_VERSION );
+  }
 …
    */
   public function vtables_db_endpoints() {
+    register_rest_field(
+      'user',
+      'user_email',
+      [
+        'get_callback' => static function (array $user): string {
+          return get_userdata($user['id'])->user_email;
+        },
+      ]
+    );
+    include VTABLES_DIR . 'includes/endpoints.php';
+  }
+    include_once VTABLES_DIR . 'includes/endpoints.php';
+  }
+  /**
+   * LEGACY ROW MIGRATION (WP-CRON)
+   * Moves 0.2.x inline source->rows into wp_vtables_source in the background.
+   * Included after db_endpoints() — the worker persists through
+   * vtables_replace_source_rows() and friends defined there.
+   */
+  public function vtables_migrate_rows() {
+    include_once VTABLES_DIR . 'includes/migrate-rows.php';
+  }
+}
+if (
+  in_array( 'vtables-pro/vtables-pro.php', apply_filters( 'active_plugins', get_option( 'active_plugins' ) ) ) ||
+  in_array( 'vtables.pro/vtables-pro.php', apply_filters( 'active_plugins', get_option( 'active_plugins' ) ) )
+) {
+  // Do nothing as Pro version installed and activated.
+} else {
+  (new vTables())->vtables_boot();
+/**
+ * ACTIVATE PLUGIN
+ * Registered at file level: WordPress fires the activation hook on a request
+ * where plugins_loaded has already run.
+ */
+register_activation_hook( __FILE__, 'vtables_activate' );
+function vtables_activate( $network_wide = false ) {
+  require_once VTABLES_DIR . 'includes/autoload.php';
+  $activator = new \vTables\Classes\Activator();
+  $activator->vtables_migrate_databases( $network_wide );
+  // 'init' already fired for this request, so the embed rule has to be
+  // registered here or the flush would rebuild the rewrite array without it.
+  \vTables\Classes\Embed::register_rewrite();
+  flush_rewrite_rules( false );
+}
+/**
+ * DEACTIVATE PLUGIN
+ */
+register_deactivation_hook( __FILE__, 'vtables_deactivate' );
+function vtables_deactivate() {
+  wp_clear_scheduled_hook( 'vtables_migrate_rows_tick' );
+  delete_option( 'vtables_rewrite_version' );
+  flush_rewrite_rules( false );
+}
+/**
+ * BOOT
+ * Deferred to plugins_loaded so every plugin has been included first: when
+ * vTables Pro is running it owns the admin screen, the shortcode, the embed
+ * document and the endpoints (on the same tables and URLs), and this plugin
+ * stays dormant.
+ */
+add_action( 'plugins_loaded', 'vtables_bootstrap' );
+function vtables_bootstrap() {
+  if ( vtables_is_pro_running() ) {
+    return;
+  }
+  ( new vTables() )->vtables_boot();
+}

Plugin Directory

Context Navigation

Legend:

vtables/trunk/dist/spa/css/vtables.css

vtables/trunk/dist/spa/index.html

vtables/trunk/includes/Classes/Activator.php

vtables/trunk/includes/Classes/LoadAssets.php

vtables/trunk/includes/autoload.php

vtables/trunk/includes/endpoints.php

vtables/trunk/includes/shortcode.html

vtables/trunk/index.html

vtables/trunk/package-lock.json

vtables/trunk/package.json

vtables/trunk/public/css/vtables.css

vtables/trunk/quasar.config.js

vtables/trunk/readme.txt

vtables/trunk/src/boot/i18n.ts

vtables/trunk/src/boot/services.ts

vtables/trunk/src/boot/wpapi.ts

vtables/trunk/src/css/app.scss

vtables/trunk/src/i18n/en-US/index.ts

vtables/trunk/src/i18n/index.ts

vtables/trunk/uninstall.php

vtables/trunk/vtables.php

Download in other formats: