@walkthru-earth/objex 1.3.1 → 1.4.0

package/dist/utils/geometry-type.d.ts

@@ -1,52 +0,0 @@
-/**
- * Helpers for parsing DuckDB v1.5 parameterized GEOMETRY type strings.
- *
- * DuckDB v1.5 made GEOMETRY a core type with an optional CRS parameter:
- *   GEOMETRY                  — no CRS attached
- *   GEOMETRY('EPSG:4326')     — EPSG form
- *   GEOMETRY('OGC:CRS84')     — OGC form (canonical for GeoParquet 1.1+)
- *   GEOMETRY('EPSG:27700')    — projected CRS
- *
- * Type strings may come from `DESCRIBE`, from the Arrow schema, or from a
- * legacy code path that still reports `BLOB`. Use these helpers everywhere
- * instead of ad-hoc regex so behaviour stays consistent.
- */
-export interface GeometryTypeInfo {
-    /** True if the type is some form of GEOMETRY (with or without CRS). */
-    isGeometry: boolean;
-    /** True if the type carries a CRS parameter, e.g. GEOMETRY('EPSG:4326'). */
-    hasCrs: boolean;
-    /** The CRS string if present, otherwise null. Raw value, including WGS84. */
-    rawCrs: string | null;
-    /**
-     * The CRS string if present and NOT a WGS84 variant (EPSG:4326, EPSG:4979,
-     * OGC:CRS84). Returns null for WGS84 so callers can skip ST_Transform.
-     */
-    nonWgs84Crs: string | null;
-}
-/**
- * Parse a DuckDB type string and report whether it is a GEOMETRY type, and
- * whether a CRS parameter is attached.
- */
-export declare function parseGeometryTypeCrs(typeStr: string | null | undefined): GeometryTypeInfo;
-/** True for EPSG:4326, EPSG:4979, OGC:CRS84 and equivalent strings. */
-export declare function isWgs84Crs(crs: string | null | undefined): boolean;
-/**
- * Build a `ST_Transform(...)` SQL expression choosing the 2-arg form when the
- * input already carries its CRS in the GEOMETRY type (DuckDB v1.5), and the
- * 3-arg form otherwise.
- *
- * `geometry_always_xy` is set globally at DB init, so no per-call `always_xy`
- * argument is needed.
- */
-export declare function buildTransformExpr(innerExpr: string, sourceType: string, sourceCrs: string, targetCrs: string): string;
-/**
- * Wrap a bare WKB expression with `ST_SetCRS(ST_GeomFromWKB(...))` so that the
- * resulting GEOMETRY value carries a CRS through the rest of the pipeline.
- * Used in the legacy GeoParquet fallback where we read the geometry column as
- * BLOB but still know the source CRS from hyparquet metadata or the GeoParquet
- * footer.
- *
- * If `sourceCrs` is null/empty, returns a plain `ST_GeomFromWKB(...)`.
- */
-export declare function wrapWkbWithCrs(wkbExpr: string, sourceCrs: string | null | undefined): string;

package/dist/utils/geometry-type.js

@@ -1,76 +0,0 @@
-/**
- * Helpers for parsing DuckDB v1.5 parameterized GEOMETRY type strings.
- *
- * DuckDB v1.5 made GEOMETRY a core type with an optional CRS parameter:
- *   GEOMETRY                  — no CRS attached
- *   GEOMETRY('EPSG:4326')     — EPSG form
- *   GEOMETRY('OGC:CRS84')     — OGC form (canonical for GeoParquet 1.1+)
- *   GEOMETRY('EPSG:27700')    — projected CRS
- *
- * Type strings may come from `DESCRIBE`, from the Arrow schema, or from a
- * legacy code path that still reports `BLOB`. Use these helpers everywhere
- * instead of ad-hoc regex so behaviour stays consistent.
- */
-import { WGS84_CODES } from '../constants.js';
-const GEOMETRY_PREFIX = /^GEOMETRY(\s*\(\s*'?([^')]+)'?\s*\))?/i;
-/**
- * Parse a DuckDB type string and report whether it is a GEOMETRY type, and
- * whether a CRS parameter is attached.
- */
-export function parseGeometryTypeCrs(typeStr) {
-    if (!typeStr)
-        return { isGeometry: false, hasCrs: false, rawCrs: null, nonWgs84Crs: null };
-    const match = typeStr.match(GEOMETRY_PREFIX);
-    if (!match)
-        return { isGeometry: false, hasCrs: false, rawCrs: null, nonWgs84Crs: null };
-    const rawCrs = match[2]?.trim() ?? null;
-    if (!rawCrs)
-        return { isGeometry: true, hasCrs: false, rawCrs: null, nonWgs84Crs: null };
-    return {
-        isGeometry: true,
-        hasCrs: true,
-        rawCrs,
-        nonWgs84Crs: isWgs84Crs(rawCrs) ? null : rawCrs
-    };
-}
-/** True for EPSG:4326, EPSG:4979, OGC:CRS84 and equivalent strings. */
-export function isWgs84Crs(crs) {
-    if (!crs)
-        return true;
-    const trimmed = crs.trim();
-    if (trimmed === 'OGC:CRS84' || trimmed === 'OGC:CRS83')
-        return true;
-    const epsgMatch = trimmed.match(/^EPSG:(\d+)$/i);
-    if (epsgMatch && WGS84_CODES.has(Number(epsgMatch[1])))
-        return true;
-    return false;
-}
-/**
- * Build a `ST_Transform(...)` SQL expression choosing the 2-arg form when the
- * input already carries its CRS in the GEOMETRY type (DuckDB v1.5), and the
- * 3-arg form otherwise.
- *
- * `geometry_always_xy` is set globally at DB init, so no per-call `always_xy`
- * argument is needed.
- */
-export function buildTransformExpr(innerExpr, sourceType, sourceCrs, targetCrs) {
-    const info = parseGeometryTypeCrs(sourceType);
-    if (info.hasCrs) {
-        return `ST_Transform(${innerExpr}, '${targetCrs}')`;
-    }
-    return `ST_Transform(${innerExpr}, '${sourceCrs}', '${targetCrs}')`;
-}
-/**
- * Wrap a bare WKB expression with `ST_SetCRS(ST_GeomFromWKB(...))` so that the
- * resulting GEOMETRY value carries a CRS through the rest of the pipeline.
- * Used in the legacy GeoParquet fallback where we read the geometry column as
- * BLOB but still know the source CRS from hyparquet metadata or the GeoParquet
- * footer.
- *
- * If `sourceCrs` is null/empty, returns a plain `ST_GeomFromWKB(...)`.
- */
-export function wrapWkbWithCrs(wkbExpr, sourceCrs) {
-    if (!sourceCrs)
-        return `ST_GeomFromWKB(${wkbExpr})`;
-    return `ST_SetCRS(ST_GeomFromWKB(${wkbExpr}), '${sourceCrs}')`;
-}

package/dist/utils/hex.d.ts

@@ -1,10 +0,0 @@
-export interface HexRow {
-    offset: string;
-    hex: string[];
-    ascii: string;
-}
-/**
- * Generates a hex dump from binary data.
- * Returns rows of offset | hex bytes | ASCII representation.
- */
-export declare function generateHexDump(data: Uint8Array, bytesPerRow?: number): HexRow[];

package/dist/utils/hex.js

@@ -1,27 +0,0 @@
-/**
- * Generates a hex dump from binary data.
- * Returns rows of offset | hex bytes | ASCII representation.
- */
-export function generateHexDump(data, bytesPerRow = 16) {
-    const rows = [];
-    for (let i = 0; i < data.length; i += bytesPerRow) {
-        const slice = data.slice(i, i + bytesPerRow);
-        const offset = i.toString(16).padStart(8, '0');
-        const hex = [];
-        for (let j = 0; j < bytesPerRow; j++) {
-            if (j < slice.length) {
-                hex.push(slice[j].toString(16).padStart(2, '0'));
-            }
-            else {
-                hex.push('  ');
-            }
-        }
-        let ascii = '';
-        for (let j = 0; j < slice.length; j++) {
-            const byte = slice[j];
-            ascii += byte >= 0x20 && byte <= 0x7e ? String.fromCharCode(byte) : '.';
-        }
-        rows.push({ offset, hex, ascii });
-    }
-    return rows;
-}

package/dist/utils/host-detection.d.ts

@@ -1,23 +0,0 @@
-/**
- * Auto-detect hosting bucket from URL search params and window.location.
- *
- * Detection priority:
- * 1. `?url=<storage-url>` query parameter (highest priority)
- * 2. `window.location.hostname` pattern matching (fallback)
- *
- * Also extracts `rootPrefix` when the app is hosted inside a subfolder.
- */
-import type { StorageProvider } from './storage-url.js';
-export interface DetectedHost {
-    provider: StorageProvider;
-    bucket: string;
-    region: string;
-    endpoint: string;
-    rootPrefix: string;
-    bucketUrl: string;
-}
-/**
- * Detect hosting bucket from current URL.
- * Returns null when no hosting bucket can be determined.
- */
-export declare function detectHostBucket(): DetectedHost | null;

package/dist/utils/host-detection.js

@@ -1,95 +0,0 @@
-/**
- * Auto-detect hosting bucket from URL search params and window.location.
- *
- * Detection priority:
- * 1. `?url=<storage-url>` query parameter (highest priority)
- * 2. `window.location.hostname` pattern matching (fallback)
- *
- * Also extracts `rootPrefix` when the app is hosted inside a subfolder.
- */
-import { buildProviderBaseUrl } from '../storage/providers.js';
-import { isKnownBucketHost, parseStorageUrl } from './storage-url.js';
-/**
- * Extract root prefix from pathname.
- * When hosted at `/subfolder/index.html` or `/subfolder/`, returns `subfolder/`.
- */
-function extractRootPrefix(pathname) {
-    // Strip trailing filename (index.html, etc.)
-    let clean = pathname.replace(/\/[^/]*\.[^/]*$/, '/');
-    // Remove leading slash
-    clean = clean.replace(/^\//, '');
-    // Empty or just '/' means no prefix
-    if (!clean || clean === '/')
-        return '';
-    // Ensure trailing slash
-    if (!clean.endsWith('/'))
-        clean += '/';
-    return clean;
-}
-/**
- * Build a normalized API endpoint URL for a detected provider.
- */
-function buildBucketUrl(provider, endpoint, bucket, region) {
-    return buildProviderBaseUrl((provider === 'unknown' ? 's3' : provider), endpoint, bucket, region || '');
-}
-/**
- * Translate a `ParsedStorageUrl` into a `DetectedHost`. Returns null when the
- * parser did not recognize a bucket or when the host is not a known provider
- * pattern (prevents arbitrary custom endpoints from being auto-connected).
- */
-function parsedToHost(parsed, host, rootPrefix) {
-    if (!parsed.bucket || !isKnownBucketHost(host))
-        return null;
-    const provider = parsed.provider === 'unknown' ? 's3' : parsed.provider;
-    return {
-        provider,
-        bucket: parsed.bucket,
-        region: parsed.region,
-        endpoint: parsed.endpoint,
-        rootPrefix,
-        bucketUrl: buildBucketUrl(parsed.provider, parsed.endpoint, parsed.bucket, parsed.region)
-    };
-}
-/**
- * Detect hosting bucket from current URL.
- * Returns null when no hosting bucket can be determined.
- */
-export function detectHostBucket() {
-    if (typeof window === 'undefined')
-        return null;
-    const url = new URL(window.location.href);
-    // Priority 1: ?url= query parameter
-    const urlParam = url.searchParams.get('url');
-    if (urlParam) {
-        try {
-            const paramUrl = new URL(urlParam);
-            const parsed = parseStorageUrl(urlParam);
-            const host = parsedToHost(parsed, paramUrl.hostname, '');
-            if (host)
-                return host;
-        }
-        catch {
-            // Not a parseable URL, fall through to location-based detection.
-        }
-    }
-    // Priority 2: window.location pattern matching via the unified parser.
-    // `parseStorageUrl` extracts bucket + any remaining prefix from the
-    // current URL. The prefix is used as the in-bucket sub-folder the app
-    // should root into when auto-connecting.
-    const parsed = parseStorageUrl(window.location.href);
-    if (!parsed.bucket || !isKnownBucketHost(url.hostname))
-        return null;
-    // `rootPrefix` is the in-bucket sub-folder, possibly trailing with an
-    // `index.html` style filename, which `extractRootPrefix` strips.
-    const prefixPath = parsed.prefix ? `/${parsed.prefix}` : '';
-    const rootPrefix = extractRootPrefix(prefixPath || '/');
-    const provider = parsed.provider === 'unknown' ? 's3' : parsed.provider;
-    return {
-        provider,
-        bucket: parsed.bucket,
-        region: parsed.region,
-        endpoint: parsed.endpoint,
-        rootPrefix,
-        bucketUrl: buildBucketUrl(parsed.provider, parsed.endpoint, parsed.bucket, parsed.region)
-    };
-}

package/dist/utils/local-storage.d.ts

@@ -1,16 +0,0 @@
-/**
- * Generic localStorage helpers with SSR safety.
- *
- * Used by connection, settings, and query-history stores to avoid
- * repeating the same load/persist/try-catch/SSR-guard pattern.
- */
-/**
- * Load a JSON value from localStorage.
- * Returns `defaultValue` on SSR, missing key, or parse error.
- */
-export declare function loadFromStorage<T>(key: string, defaultValue: T): T;
-/**
- * Persist a JSON-serializable value to localStorage.
- * Silently no-ops on SSR or storage errors (quota, private browsing).
- */
-export declare function persistToStorage(key: string, value: unknown): void;

package/dist/utils/local-storage.js

@@ -1,37 +0,0 @@
-/**
- * Generic localStorage helpers with SSR safety.
- *
- * Used by connection, settings, and query-history stores to avoid
- * repeating the same load/persist/try-catch/SSR-guard pattern.
- */
-/**
- * Load a JSON value from localStorage.
- * Returns `defaultValue` on SSR, missing key, or parse error.
- */
-export function loadFromStorage(key, defaultValue) {
-    if (typeof window === 'undefined')
-        return defaultValue;
-    try {
-        const raw = localStorage.getItem(key);
-        if (raw)
-            return JSON.parse(raw);
-    }
-    catch {
-        // ignore parse errors
-    }
-    return defaultValue;
-}
-/**
- * Persist a JSON-serializable value to localStorage.
- * Silently no-ops on SSR or storage errors (quota, private browsing).
- */
-export function persistToStorage(key, value) {
-    if (typeof window === 'undefined')
-        return;
-    try {
-        localStorage.setItem(key, JSON.stringify(value));
-    }
-    catch {
-        // ignore storage errors
-    }
-}

package/dist/utils/markdown-sql.d.ts

@@ -1,30 +0,0 @@
-export interface SqlBlock {
-    name: string;
-    sql: string;
-    startLine: number;
-    endLine: number;
-}
-export interface ParsedMarkdownDocument {
-    frontmatter: Record<string, any>;
-    content: string;
-    sqlBlocks: SqlBlock[];
-}
-/**
- * Parse a markdown document with YAML frontmatter and SQL code blocks.
- *
- * Evidence-compatible syntax:
- * ```sql query_name
- * SELECT * FROM table
- * ```
- */
-export declare function parseMarkdownDocument(markdown: string): Promise<ParsedMarkdownDocument>;
-/**
- * Interpolate template variables in markdown text.
- * Supports {queryName.rows[0].columnName} syntax.
- */
-export declare function interpolateTemplates(text: string, queryResults: Map<string, Record<string, any>[]>): string;
-/**
- * Replace SQL blocks in markdown content with placeholder markers
- * that can be replaced with rendered components.
- */
-export declare function markSqlBlocks(content: string): string;

package/dist/utils/markdown-sql.js

@@ -1,72 +0,0 @@
-/**
- * Parse a markdown document with YAML frontmatter and SQL code blocks.
- *
- * Evidence-compatible syntax:
- * ```sql query_name
- * SELECT * FROM table
- * ```
- */
-export async function parseMarkdownDocument(markdown) {
-    let frontmatter = {};
-    let content = markdown;
-    const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---\n/);
-    if (fmMatch) {
-        try {
-            const { default: YAML } = await import('yaml');
-            frontmatter = YAML.parse(fmMatch[1]) || {};
-        }
-        catch {
-            // Invalid YAML or yaml peer dep not installed, ignore frontmatter
-        }
-        content = markdown.slice(fmMatch[0].length);
-    }
-    // Extract SQL blocks
-    const sqlBlocks = [];
-    const lines = content.split('\n');
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i];
-        const match = line.match(/^```sql\s+(\w[\w-]*)\s*$/);
-        if (match) {
-            const name = match[1];
-            const startLine = i;
-            const sqlLines = [];
-            i++;
-            while (i < lines.length && lines[i] !== '```') {
-                sqlLines.push(lines[i]);
-                i++;
-            }
-            sqlBlocks.push({
-                name,
-                sql: sqlLines.join('\n'),
-                startLine,
-                endLine: i
-            });
-        }
-        i++;
-    }
-    return { frontmatter, content, sqlBlocks };
-}
-/**
- * Interpolate template variables in markdown text.
- * Supports {queryName.rows[0].columnName} syntax.
- */
-export function interpolateTemplates(text, queryResults) {
-    return text.replace(/\{(\w+)\.rows\[(\d+)\]\.(\w+)\}/g, (match, queryName, rowIdx, colName) => {
-        const rows = queryResults.get(queryName);
-        if (!rows)
-            return match;
-        const row = rows[parseInt(rowIdx, 10)];
-        if (!row)
-            return match;
-        const value = row[colName];
-        return value !== undefined ? String(value) : match;
-    });
-}
-/**
- * Replace SQL blocks in markdown content with placeholder markers
- * that can be replaced with rendered components.
- */
-export function markSqlBlocks(content) {
-    return content.replace(/```sql\s+(\w[\w-]*)\s*\n([\s\S]*?)```/g, (_, name) => `<div data-sql-block="${name}"></div>`);
-}

package/dist/utils/notebook.d.ts

@@ -1,59 +0,0 @@
-/**
- * Lightweight browser-native Jupyter notebook renderer.
- * Replaces `notebookjs` which depends on jsdom/Buffer (Node.js only).
- * Handles nbformat 2, 3, 4, and 5.
- */
-export interface NotebookConfig {
-    markdown: (md: string) => string;
-    ansi: (text: string) => string;
-    highlighter: (code: string, lang: string) => string;
-}
-interface RawNotebook {
-    nbformat: number;
-    nbformat_minor?: number;
-    metadata?: Record<string, any>;
-    cells?: RawCell[];
-    worksheets?: {
-        cells: RawCell[];
-    }[];
-}
-interface RawCell {
-    cell_type: string;
-    source?: string | string[];
-    input?: string | string[];
-    outputs?: RawOutput[];
-    prompt_number?: number;
-    execution_count?: number | null;
-    level?: number;
-    language?: string;
-}
-interface RawOutput {
-    output_type: string;
-    data?: Record<string, string | string[]>;
-    text?: string | string[];
-    stream?: string;
-    name?: string;
-    png?: string;
-    jpeg?: string;
-    svg?: string;
-    html?: string;
-    latex?: string;
-    traceback?: string[];
-    ename?: string;
-    evalue?: string;
-    [key: string]: any;
-}
-export interface NotebookMeta {
-    kernelName: string;
-    language: string;
-    cellCount: number;
-}
-/**
- * Parse and render a Jupyter notebook JSON to a DOM element.
- * Returns the rendered element and metadata.
- */
-export declare function renderNotebook(raw: RawNotebook, config: NotebookConfig): {
-    element: HTMLElement;
-    meta: NotebookMeta;
-};
-export {};