@lix-js/sdk 0.6.0-preview.4 → 0.6.0

package/dist/engine-wasm/index.js

@@ -1,339 +0,0 @@
-export { default } from "./wasm/lix_engine.js";
-export * from "./wasm/lix_engine.js";
-export class Value {
-    kind;
-    value;
-    base64;
-    constructor(kind, value, base64) {
-        this.kind = kind;
-        this.value = value;
-        this.base64 = base64;
-    }
-    static null() {
-        return new Value("null", null);
-    }
-    static integer(value) {
-        if (!Number.isFinite(value) || !Number.isInteger(value)) {
-            throw new TypeError("Value.integer() requires a finite integer number");
-        }
-        return new Value("integer", value);
-    }
-    static boolean(value) {
-        return new Value("boolean", value);
-    }
-    static real(value) {
-        if (!Number.isFinite(value)) {
-            throw new TypeError("Value.real() requires a finite number");
-        }
-        return new Value("real", value);
-    }
-    static text(value) {
-        if (!isWellFormedUtf16(value)) {
-            throw new TypeError("Value.text() requires a well-formed UTF-16 string");
-        }
-        return new Value("text", value);
-    }
-    static json(value) {
-        return new Value("json", normalizeJsonValue(value));
-    }
-    static blob(value) {
-        return new Value("blob", undefined, bytesToBase64(value));
-    }
-    static from(raw) {
-        if (raw instanceof Value)
-            return raw;
-        if (isLixValue(raw)) {
-            switch (raw.kind) {
-                case "null":
-                    return Value.null();
-                case "boolean":
-                    return Value.boolean(raw.value);
-                case "integer":
-                    return Value.integer(raw.value);
-                case "real":
-                    return Value.real(raw.value);
-                case "text":
-                    return Value.text(raw.value);
-                case "json":
-                    return Value.json(normalizeJsonValue(raw.value));
-                case "blob":
-                    return new Value("blob", undefined, raw.base64);
-            }
-        }
-        if (raw === null)
-            return Value.null();
-        if (raw === undefined) {
-            throw new TypeError("undefined is not a valid SQL parameter");
-        }
-        if (typeof raw === "number") {
-            return Number.isInteger(raw) ? Value.integer(raw) : Value.real(raw);
-        }
-        if (typeof raw === "boolean")
-            return Value.boolean(raw);
-        if (typeof raw === "string")
-            return Value.text(raw);
-        if (raw instanceof Uint8Array)
-            return Value.blob(raw);
-        if (raw instanceof ArrayBuffer)
-            return Value.blob(new Uint8Array(raw));
-        if (ArrayBuffer.isView(raw)) {
-            throw new TypeError("typed array SQL parameters must be Uint8Array; other ArrayBuffer views are ambiguous");
-        }
-        if (raw instanceof Date) {
-            throw new TypeError("Date is not a valid SQL parameter; pass date.toISOString() or date.getTime() explicitly");
-        }
-        if (raw && typeof raw === "object") {
-            return Value.json(normalizeJsonValue(raw));
-        }
-        throw new TypeError("Value.from() requires a LixValue, JSON value, or binary value");
-    }
-    asInteger() {
-        return this.kind === "integer" ? this.value : undefined;
-    }
-    asBoolean() {
-        return this.kind === "boolean" ? this.value : undefined;
-    }
-    asReal() {
-        return this.kind === "real" ? this.value : undefined;
-    }
-    asText() {
-        return this.kind === "text" ? this.value : undefined;
-    }
-    asJson() {
-        return this.kind === "json" ? normalizeJsonValue(this.value) : undefined;
-    }
-    asBlob() {
-        return this.kind === "blob" && this.base64 !== undefined
-            ? base64ToBytes(this.base64)
-            : undefined;
-    }
-    toJSON() {
-        switch (this.kind) {
-            case "null":
-                return { kind: "null", value: null };
-            case "boolean":
-                return { kind: "boolean", value: this.asBoolean() ?? false };
-            case "integer":
-                return { kind: "integer", value: this.asInteger() ?? 0 };
-            case "real":
-                return { kind: "real", value: this.asReal() ?? 0 };
-            case "text":
-                return { kind: "text", value: this.asText() ?? "" };
-            case "json":
-                return { kind: "json", value: this.asJson() ?? null };
-            case "blob":
-                return { kind: "blob", base64: this.base64 ?? "" };
-        }
-    }
-}
-/**
- * Type guard: returns `true` when `err` is a Lix-produced error carrying a
- * structured `code` field (all engine codes start with `LIX_`).
- */
-export function isLixError(err) {
-    return (err instanceof Error &&
-        typeof err.code === "string" &&
-        err.code.startsWith("LIX_"));
-}
-function isLixValue(value) {
-    if (!value || typeof value !== "object") {
-        return false;
-    }
-    const kind = value.kind;
-    if (kind === "null") {
-        return value.value === null;
-    }
-    if (kind === "boolean") {
-        return typeof value.value === "boolean";
-    }
-    if (kind === "integer" || kind === "real") {
-        const raw = value.value;
-        if (typeof raw !== "number" || !Number.isFinite(raw)) {
-            return false;
-        }
-        if (kind === "integer" && !Number.isInteger(raw)) {
-            return false;
-        }
-        return true;
-    }
-    if (kind === "text") {
-        const raw = value.value;
-        return typeof raw === "string" && isWellFormedUtf16(raw);
-    }
-    if (kind === "json") {
-        return isJsonValue(value.value);
-    }
-    if (kind === "blob") {
-        return typeof value.base64 === "string";
-    }
-    return false;
-}
-function isJsonValue(value) {
-    try {
-        normalizeJsonValue(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function normalizeJsonValue(value, seen = new WeakSet()) {
-    if (value === null ||
-        typeof value === "boolean") {
-        return value;
-    }
-    if (typeof value === "string") {
-        if (!isWellFormedUtf16(value)) {
-            throw new TypeError("JSON strings must be well-formed UTF-16");
-        }
-        return value;
-    }
-    if (typeof value === "number") {
-        if (!Number.isFinite(value)) {
-            throw new TypeError("JSON numbers must be finite");
-        }
-        return value;
-    }
-    if (Array.isArray(value)) {
-        if (seen.has(value)) {
-            throw new TypeError("JSON values must not contain circular references");
-        }
-        seen.add(value);
-        const normalized = value.map((item) => normalizeJsonValue(item, seen));
-        seen.delete(value);
-        return normalized;
-    }
-    if (!value || typeof value !== "object") {
-        throw new TypeError("expected a JSON-compatible value");
-    }
-    if (value instanceof Date) {
-        throw new TypeError("Date is not a JSON value");
-    }
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
-        throw new TypeError("JSON objects must be plain objects");
-    }
-    if (seen.has(value)) {
-        throw new TypeError("JSON values must not contain circular references");
-    }
-    seen.add(value);
-    const normalized = {};
-    for (const [key, entry] of Object.entries(value)) {
-        if (!isWellFormedUtf16(key)) {
-            throw new TypeError("JSON object keys must be well-formed UTF-16");
-        }
-        normalized[key] = normalizeJsonValue(entry, seen);
-    }
-    seen.delete(value);
-    return normalized;
-}
-function isWellFormedUtf16(value) {
-    for (let index = 0; index < value.length; index += 1) {
-        const code = value.charCodeAt(index);
-        if (code >= 0xd800 && code <= 0xdbff) {
-            const next = value.charCodeAt(index + 1);
-            if (next < 0xdc00 || next > 0xdfff) {
-                return false;
-            }
-            index += 1;
-            continue;
-        }
-        if (code >= 0xdc00 && code <= 0xdfff) {
-            return false;
-        }
-    }
-    return true;
-}
-function bytesToBase64(bytes) {
-    const maybeBuffer = globalThis.Buffer;
-    if (maybeBuffer) {
-        return maybeBuffer.from(bytes).toString("base64");
-    }
-    let binary = "";
-    const chunkSize = 0x8000;
-    for (let index = 0; index < bytes.length; index += chunkSize) {
-        const chunk = bytes.subarray(index, index + chunkSize);
-        binary += String.fromCharCode(...chunk);
-    }
-    return btoa(binary);
-}
-function base64ToBytes(base64) {
-    const maybeBuffer = globalThis.Buffer;
-    if (maybeBuffer) {
-        return new Uint8Array(maybeBuffer.from(base64, "base64"));
-    }
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for (let index = 0; index < binary.length; index += 1) {
-        bytes[index] = binary.charCodeAt(index);
-    }
-    return bytes;
-}
-const engineWasmUrl = new URL("./wasm/lix_engine.wasm", import.meta.url);
-function isNodeRuntime() {
-    const processLike = globalThis.process;
-    return (!!processLike &&
-        typeof processLike.versions === "object" &&
-        !!processLike.versions?.node);
-}
-async function tryReadNodeFileFromViteHttpUrl(url) {
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-        return undefined;
-    }
-    // Vitest/Vite in Node often rewrites module URLs to http://localhost with /@fs/.
-    const decodedPathname = decodeURIComponent(url.pathname);
-    let filePath;
-    if (decodedPathname.startsWith("/@fs/")) {
-        filePath = decodedPathname.slice("/@fs".length);
-    }
-    else if (url.hostname === "localhost" ||
-        url.hostname === "127.0.0.1" ||
-        url.hostname === "::1") {
-        // Some setups expose absolute filesystem paths directly on localhost.
-        filePath = decodedPathname;
-    }
-    if (!filePath) {
-        return undefined;
-    }
-    const fsModuleName = "node:fs/promises";
-    const { readFile } = await import(fsModuleName);
-    try {
-        return new Uint8Array(await readFile(filePath));
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Returns a wasm-bindgen-compatible init input that works in both browser and Node.
- *
- * - Browser: use a URL so the runtime fetches the `.wasm` asset.
- * - Node: read bytes from disk because `fetch(file://...)` is not supported.
- */
-export async function resolveEngineWasmModuleOrPath() {
-    if (!isNodeRuntime()) {
-        return engineWasmUrl;
-    }
-    if (engineWasmUrl.protocol === "file:") {
-        const fsModuleName = "node:fs/promises";
-        const urlModuleName = "node:url";
-        const [{ readFile }, { fileURLToPath }] = await Promise.all([
-            import(fsModuleName),
-            import(urlModuleName),
-        ]);
-        return readFile(fileURLToPath(engineWasmUrl));
-    }
-    if (engineWasmUrl.protocol === "http:" ||
-        engineWasmUrl.protocol === "https:") {
-        const localBytes = await tryReadNodeFileFromViteHttpUrl(engineWasmUrl);
-        if (localBytes) {
-            return localBytes;
-        }
-        const response = await fetch(engineWasmUrl);
-        if (!response.ok) {
-            throw new Error(`failed to fetch wasm module from '${engineWasmUrl.toString()}': ${response.status} ${response.statusText}`);
-        }
-        return new Uint8Array(await response.arrayBuffer());
-    }
-    return engineWasmUrl;
-}

package/dist/engine-wasm/wasm/lix_engine.d.ts

@@ -1,79 +0,0 @@
-/**
- * @param {any | null} [args]
- * @returns {Promise<Lix>}
- */
-export function openLix(args?: any | null): Promise<Lix>;
-export class Lix {
-    static __wrap(ptr: any): any;
-    __destroy_into_raw(): number | undefined;
-    __wbg_ptr: number | undefined;
-    free(): void;
-    /**
-     * @returns {Promise<string>}
-     */
-    activeVersionId(): Promise<string>;
-    /**
-     * @returns {Promise<LixTransaction>}
-     */
-    beginTransaction(): Promise<LixTransaction>;
-    /**
-     * @returns {Promise<void>}
-     */
-    close(): Promise<void>;
-    /**
-     * @param {any} args
-     * @returns {Promise<any>}
-     */
-    createVersion(args: any): Promise<any>;
-    /**
-     * Executes one DataFusion SQL statement against this Lix session.
-     *
-     * The SQL dialect is DataFusion SQL, not SQLite SQL. Positional
-     * placeholders use `?` or `$1`, `$2`, and so on. SQLite-specific catalog
-     * tables and transaction statements such as `sqlite_master`, `BEGIN`,
-     * and `COMMIT` are not part of this contract; use
-     * `information_schema` for catalog inspection.
-     * @param {any} sql
-     * @param {any} params
-     * @returns {Promise<any>}
-     */
-    execute(sql: any, params: any): Promise<any>;
-    /**
-     * @param {any} args
-     * @returns {Promise<any>}
-     */
-    mergeVersion(args: any): Promise<any>;
-    /**
-     * @param {any} args
-     * @returns {Promise<any>}
-     */
-    mergeVersionPreview(args: any): Promise<any>;
-    /**
-     * @param {any} args
-     * @returns {Promise<any>}
-     */
-    switchVersion(args: any): Promise<any>;
-}
-export class LixTransaction {
-    static __wrap(ptr: any): any;
-    __destroy_into_raw(): number | undefined;
-    __wbg_ptr: number | undefined;
-    free(): void;
-    /**
-     * @returns {Promise<void>}
-     */
-    commit(): Promise<void>;
-    /**
-     * @param {any} sql
-     * @param {any} params
-     * @returns {Promise<any>}
-     */
-    execute(sql: any, params: any): Promise<any>;
-    /**
-     * @returns {Promise<void>}
-     */
-    rollback(): Promise<void>;
-}
-export function initSync(module: any): any;
-declare function __wbg_init(module_or_path: any): Promise<any>;
-export { __wbg_init as default };