sqlite-hub 0.12.0 → 0.17.0

package/frontend/js/utils/copyColumnExport.js

@@ -0,0 +1,117 @@
+export const COPY_COLUMN_MODE_VALUES = ["column", "column-with-header", "first-10", "markdown-todo"];
+
+export function normalizeCopyColumnMode(mode) {
+  const normalizedMode = String(mode ?? "").trim();
+  return COPY_COLUMN_MODE_VALUES.includes(normalizedMode) ? normalizedMode : "column";
+}
+
+export function isMarkdownTodoCopyColumnMode(mode) {
+  return normalizeCopyColumnMode(mode) === "markdown-todo";
+}
+
+export function getCopyColumnActionLabel(copyMode) {
+  const normalizedMode = normalizeCopyColumnMode(copyMode);
+
+  if (normalizedMode === "column-with-header") {
+    return "Copy column with header";
+  }
+
+  if (normalizedMode === "first-10") {
+    return "Copy first 10";
+  }
+
+  if (normalizedMode === "markdown-todo") {
+    return "Export as Markdown Todo";
+  }
+
+  return "Copy column";
+}
+
+export function getCopyColumnExportMetadata(copyMode) {
+  return isMarkdownTodoCopyColumnMode(copyMode)
+    ? {
+        extension: "md",
+        label: "Markdown",
+        mimeType: "text/markdown;charset=utf-8",
+        suffix: "markdown-todo",
+      }
+    : {
+        extension: "txt",
+        label: "TXT",
+        mimeType: "text/plain;charset=utf-8",
+        suffix: normalizeCopyColumnMode(copyMode).replaceAll("-", "_"),
+      };
+}
+
+function stringifyCopyColumnValue(value) {
+  return value === null || value === undefined ? "" : String(value);
+}
+
+function formatDelimitedCopyColumnValue(value, wrapper) {
+  const text = stringifyCopyColumnValue(value);
+  const normalizedWrapper = String(wrapper ?? "");
+
+  if (!normalizedWrapper) {
+    return text;
+  }
+
+  return `${normalizedWrapper}${text
+    .split(normalizedWrapper)
+    .join(`${normalizedWrapper}${normalizedWrapper}`)}${normalizedWrapper}`;
+}
+
+function formatMarkdownTodoValue(value) {
+  return stringifyCopyColumnValue(value).replace(/\r\n|\r|\n/g, " ");
+}
+
+function getCopyColumnSourceRows(result, copyMode) {
+  const rows = result?.rows ?? [];
+  return normalizeCopyColumnMode(copyMode) === "first-10" ? rows.slice(0, 10) : rows;
+}
+
+export function buildCopyColumnText({
+  result,
+  columnName,
+  copyMode = "column",
+  separator = ",",
+  wrapper = "",
+} = {}) {
+  const normalizedMode = normalizeCopyColumnMode(copyMode);
+  const sourceRows = getCopyColumnSourceRows(result, normalizedMode);
+  const values = sourceRows.map((row) => row?.[columnName]);
+
+  if (normalizedMode === "markdown-todo") {
+    return {
+      text: values.map((value) => `- [ ] ${formatMarkdownTodoValue(value)}`).join("\n"),
+      valueCount: values.length,
+    };
+  }
+
+  const outputValues = normalizedMode === "column-with-header" ? [columnName, ...values] : values;
+
+  return {
+    text: outputValues.map((value) => formatDelimitedCopyColumnValue(value, wrapper)).join(separator),
+    valueCount: values.length,
+  };
+}
+
+export function buildCopyColumnPreviewText({
+  result,
+  columnName,
+  copyMode = "column",
+  separator = ",",
+  wrapper = "",
+  maxRows = 4,
+} = {}) {
+  const limitedRows = {
+    rows: getCopyColumnSourceRows(result, copyMode).slice(0, Math.max(0, Number(maxRows) || 0)),
+  };
+
+  return buildCopyColumnText({
+    result: limitedRows,
+    columnName,
+    copyMode: normalizeCopyColumnMode(copyMode) === "first-10" ? "column" : copyMode,
+    separator,
+    wrapper,
+  }).text;
+}

package/frontend/js/utils/exportFilenames.js

@@ -0,0 +1,32 @@
+export const TEXT_EXPORT_EXTENSIONS = {
+  csv: "csv",
+  tsv: "tsv",
+  md: "md",
+};
+
+export function normalizeTextExportFormat(format = "csv") {
+  const normalized = String(format ?? "csv").toLowerCase();
+  return TEXT_EXPORT_EXTENSIONS[normalized] ? normalized : "csv";
+}
+
+function stripKnownTextExportExtension(value = "") {
+  return String(value).replace(/\.(csv|tsv|md)$/i, "");
+}
+
+export function sanitizeExportFilenameBase(value, fallback = "export") {
+  const sanitized = stripKnownTextExportExtension(value)
+    .replace(/[<>:"/\\|?*\u0000-\u001f]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/^[. ]+|[. ]+$/g, "");
+
+  return (sanitized || fallback).slice(0, 120);
+}
+
+export function buildTextExportFilename(value, { format = "csv", fallback = "export" } = {}) {
+  const normalizedFormat = normalizeTextExportFormat(format);
+  const extension = TEXT_EXPORT_EXTENSIONS[normalizedFormat];
+  const base = sanitizeExportFilenameBase(value, fallback);
+
+  return `${base}.${extension}`;
+}

package/frontend/js/utils/filePathPreview.js

@@ -0,0 +1,315 @@
+import { isProtectedKeyColumn } from "./timestampPreview.js";
+
+const MAX_FILEPATH_LENGTH = 2048;
+const URL_SCHEME_PATTERN = /^(?:https?:\/\/|ftp:\/\/|mailto:|tel:)/i;
+const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const NUMERIC_PATTERN = /^[+-]?\d+(?:\.\d+)?$/;
+const WINDOWS_ABSOLUTE_PATTERN = /^[A-Za-z]:[\\/]/;
+const HOME_PATH_PATTERN = /^~[\\/]/;
+const UNIX_ABSOLUTE_PATTERN = /^\//;
+const EXPLICIT_RELATIVE_PATTERN = /^(?:\.\.?[\\/])/;
+const FILEPATH_COLUMN_PATTERN = /\b(?:path|filepath|file_path|filename|file|dir|directory|folder|location)\b/i;
+const STRONG_FILENAME_COLUMN_PATTERN = /\b(?:filename|file_name|filepath|file_path|file)\b/i;
+const KNOWN_EXTENSIONS = new Set([
+  "sqlite",
+  "sqlite3",
+  "db",
+  "json",
+  "csv",
+  "tsv",
+  "txt",
+  "log",
+  "png",
+  "jpg",
+  "jpeg",
+  "webp",
+  "gif",
+  "pdf",
+  "md",
+  "html",
+  "htm",
+  "xml",
+  "zip",
+]);
+
+function normalizeValue(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function hasSeparator(value) {
+  return /[\\/]/.test(value);
+}
+
+function countSeparators(value) {
+  return (value.match(/[\\/]/g) ?? []).length;
+}
+
+function getSeparator(value) {
+  return value.includes("\\") && !value.includes("/") ? "\\" : "/";
+}
+
+function stripTrailingSeparators(value) {
+  if (WINDOWS_ABSOLUTE_PATTERN.test(value) && value.length <= 3) {
+    return value;
+  }
+
+  if (value === "/" || value === "~/" || value === "~\\") {
+    return value;
+  }
+
+  return value.replace(/[\\/]+$/, "");
+}
+
+function isJsonString(value) {
+  const text = normalizeValue(value);
+
+  if (!text || !["{", "["].includes(text[0])) {
+    return false;
+  }
+
+  try {
+    const parsed = JSON.parse(text);
+    return Boolean(parsed && typeof parsed === "object");
+  } catch {
+    return false;
+  }
+}
+
+function getSegments(value) {
+  return stripTrailingSeparators(value)
+    .split(/[\\/]+/)
+    .filter(Boolean);
+}
+
+function getColumnNameConfidence(columnName) {
+  const normalized = String(columnName ?? "").trim();
+
+  if (!normalized) {
+    return 0;
+  }
+
+  if (FILEPATH_COLUMN_PATTERN.test(normalized.replaceAll("_", " "))) {
+    return 0.25;
+  }
+
+  return 0;
+}
+
+function hasStrongFilenameColumnName(columnName) {
+  return STRONG_FILENAME_COLUMN_PATTERN.test(String(columnName ?? "").replaceAll("_", " "));
+}
+
+export function getPathType(value) {
+  const text = normalizeValue(value);
+
+  if (HOME_PATH_PATTERN.test(text)) {
+    return "home";
+  }
+
+  if (WINDOWS_ABSOLUTE_PATTERN.test(text)) {
+    return "windows";
+  }
+
+  if (UNIX_ABSOLUTE_PATTERN.test(text)) {
+    return "unix";
+  }
+
+  if (EXPLICIT_RELATIVE_PATTERN.test(text) || hasSeparator(text)) {
+    return "relative";
+  }
+
+  return null;
+}
+
+export function extractFileName(value) {
+  const text = normalizeValue(value);
+
+  if (!text || /[\\/]$/.test(text)) {
+    return null;
+  }
+
+  const segments = getSegments(text);
+  return segments.at(-1) ?? null;
+}
+
+export function extractDirectory(value) {
+  const text = normalizeValue(value);
+  const fileName = extractFileName(text);
+
+  if (!text || !fileName) {
+    return stripTrailingSeparators(text) || null;
+  }
+
+  const separator = getSeparator(text);
+  const directory = stripTrailingSeparators(text).slice(0, -fileName.length).replace(/[\\/]+$/, "");
+
+  if (!directory) {
+    return null;
+  }
+
+  if (directory === "~") {
+    return `~${separator}`;
+  }
+
+  return directory;
+}
+
+export function extractExtension(value) {
+  const fileName = extractFileName(value);
+
+  if (!fileName || fileName.startsWith(".") && fileName.indexOf(".", 1) === -1) {
+    return null;
+  }
+
+  const dotIndex = fileName.lastIndexOf(".");
+
+  if (dotIndex <= 0 || dotIndex === fileName.length - 1) {
+    return null;
+  }
+
+  return fileName.slice(dotIndex + 1).toLowerCase();
+}
+
+function hasKnownExtension(value) {
+  const extension = extractExtension(value);
+  return Boolean(extension && KNOWN_EXTENSIONS.has(extension));
+}
+
+function looksLikeExcludedValue(value) {
+  const text = normalizeValue(value);
+
+  return (
+    !text ||
+    text.length > MAX_FILEPATH_LENGTH ||
+    URL_SCHEME_PATTERN.test(text) ||
+    EMAIL_PATTERN.test(text) ||
+    NUMERIC_PATTERN.test(text) ||
+    ["true", "false"].includes(text.toLowerCase()) ||
+    isJsonString(text)
+  );
+}
+
+export function isLikelyFilePath(value) {
+  const text = normalizeValue(value);
+
+  if (looksLikeExcludedValue(text)) {
+    return false;
+  }
+
+  return Boolean(getPathType(text));
+}
+
+function getFilePathConfidence(value, columnName) {
+  const text = normalizeValue(value);
+  const pathType = getPathType(text);
+  const extension = extractExtension(text);
+  const separatorCount = countSeparators(text);
+  let confidence = 0;
+
+  if (pathType === "unix" || pathType === "windows" || pathType === "home") {
+    confidence += 0.55;
+  } else if (EXPLICIT_RELATIVE_PATTERN.test(text)) {
+    confidence += 0.45;
+  } else if (pathType === "relative") {
+    confidence += 0.4;
+  } else if (extension && hasStrongFilenameColumnName(columnName)) {
+    confidence += 0.25;
+  }
+
+  confidence += getColumnNameConfidence(columnName);
+
+  if (extension && KNOWN_EXTENSIONS.has(extension)) {
+    confidence += 0.25;
+  } else if (extension) {
+    confidence += 0.15;
+  }
+
+  if (separatorCount >= 2) {
+    confidence += 0.15;
+  } else if (separatorCount === 1) {
+    confidence += 0.05;
+  }
+
+  if (!extension && separatorCount >= 2) {
+    confidence += 0.05;
+  }
+
+  return Math.min(1, Number(confidence.toFixed(2)));
+}
+
+export function detectFilePathValue(value, columnName, tableMeta = {}) {
+  if (isProtectedKeyColumn(columnName, tableMeta)) {
+    return null;
+  }
+
+  const rawValue = normalizeValue(value);
+
+  if (looksLikeExcludedValue(rawValue)) {
+    return null;
+  }
+
+  const pathType = getPathType(rawValue);
+  const extension = extractExtension(rawValue);
+
+  if (!pathType && !(extension && hasStrongFilenameColumnName(columnName))) {
+    return null;
+  }
+
+  if (!hasSeparator(rawValue) && !(extension && hasStrongFilenameColumnName(columnName))) {
+    return null;
+  }
+
+  const confidence = getFilePathConfidence(rawValue, columnName);
+
+  if (confidence < 0.7) {
+    return null;
+  }
+
+  return {
+    type: "filepath",
+    pathType: pathType ?? "relative",
+    rawValue,
+    fileName: extractFileName(rawValue),
+    directory: extractDirectory(rawValue),
+    extension,
+    confidence,
+  };
+}
+
+export function compactPathForDisplay(value, maxLength = 42) {
+  const text = normalizeValue(value);
+
+  if (text.length <= maxLength) {
+    return text;
+  }
+
+  const separator = getSeparator(text);
+  const fileName = extractFileName(text);
+  const directory = extractDirectory(text);
+  const directorySegments = directory ? getSegments(directory) : [];
+  const parent = directorySegments.at(-1);
+  const compact = [parent, fileName].filter(Boolean).join(separator);
+  const candidate = compact ? `...${separator}${compact}` : `...${text.slice(-(maxLength - 3))}`;
+
+  if (candidate.length <= maxLength) {
+    return candidate;
+  }
+
+  return `...${candidate.slice(-(maxLength - 3))}`;
+}
+
+export function getPathTypeLabel(pathType) {
+  if (pathType === "unix") {
+    return "unix path";
+  }
+
+  if (pathType === "windows") {
+    return "windows path";
+  }
+
+  if (pathType === "home") {
+    return "home path";
+  }
+
+  return "relative path";
+}

package/frontend/js/utils/format.js

@@ -1,5 +1,5 @@
 const KEYWORD_PATTERN =
-  /\b(WITH|SELECT|FROM|WHERE|AND|OR|ORDER|BY|ASC|DESC|AS|COUNT|FILTER|JOIN|LEFT|RIGHT|INNER|OUTER|ON|GROUP|LIMIT|OFFSET|AVG|SUM|MIN|MAX|OVER|PARTITION|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP|PRAGMA|VALUES|INTO|SET|BEGIN|COMMIT|ROLLBACK)\b/gi;
+  /\b(WITH|SELECT|FROM|WHERE|AND|OR|ORDER|BY|ASC|DESC|AS|CASE|WHEN|THEN|ELSE|END|IS|NULL|CAST|TEXT|INTEGER|REAL|NUMERIC|BLOB|COUNT|FILTER|ROW_NUMBER|RANK|DENSE_RANK|LAG|LEAD|OVER|PARTITION|JOIN|LEFT|RIGHT|INNER|OUTER|ON|GROUP|LIMIT|OFFSET|AVG|SUM|MIN|MAX|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP|PRAGMA|VALUES|INTO|SET|BEGIN|COMMIT|ROLLBACK)\b/gi;
 
 const DATE_TIME_FORMATTER = new Intl.DateTimeFormat("en-GB", {
   dateStyle: "medium",