@5ive-tech/sdk 1.1.10 → 1.1.13

package/dist/wasm/compiler/utils.js

@@ -1,17 +1,235 @@
-export function createCompilerError(message, cause) {
+const COMPILER_ERROR_CODE = "COMPILER_ERROR";
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function toOptionalString(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value
+        : undefined;
+}
+function toOptionalNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function readStringMethod(target, methodName) {
+    if (!target || typeof target !== "object") {
+        return undefined;
+    }
+    const maybeMethod = target[methodName];
+    if (typeof maybeMethod !== "function") {
+        return undefined;
+    }
+    try {
+        const value = maybeMethod.call(target);
+        return toOptionalString(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readStringProperty(target, propName) {
+    if (!target || typeof target !== "object") {
+        return undefined;
+    }
+    return toOptionalString(target[propName]);
+}
+function normalizeSuggestion(suggestion) {
+    if (typeof suggestion === "string") {
+        return { message: suggestion };
+    }
+    if (!isObject(suggestion)) {
+        return undefined;
+    }
+    const message = toOptionalString(suggestion.message) ??
+        toOptionalString(suggestion.explanation);
+    if (!message) {
+        return undefined;
+    }
+    return {
+        message,
+        explanation: toOptionalString(suggestion.explanation),
+        confidence: toOptionalNumber(suggestion.confidence),
+        codeSuggestion: toOptionalString(suggestion.code_suggestion) ??
+            toOptionalString(suggestion.codeSuggestion),
+    };
+}
+function pickSuggestions(rawSuggestions) {
+    if (!Array.isArray(rawSuggestions)) {
+        return undefined;
+    }
+    const normalized = rawSuggestions
+        .map((item) => normalizeSuggestion(item))
+        .filter((item) => Boolean(item));
+    return normalized.length > 0 ? normalized : undefined;
+}
+function buildFallbackSuggestions(code) {
+    switch (code) {
+        case "E2000":
+            return [
+                {
+                    message: "Declare the variable before use with `let <name> = ...`.",
+                    confidence: 0.8,
+                },
+                {
+                    message: "Check for spelling differences between parameter/field names and usages.",
+                    confidence: 0.7,
+                },
+            ];
+        case "E0002":
+            return [
+                {
+                    message: "Check for missing closing `}`, `)`, or an incomplete function signature.",
+                    confidence: 0.75,
+                },
+            ];
+        case "E0001":
+        case "E0004":
+            return [
+                {
+                    message: "Check for missing punctuation (`;`, `{`, `}`) near the reported statement.",
+                    confidence: 0.7,
+                },
+            ];
+        default:
+            return [];
+    }
+}
+export function createCompilerError(message, cause, details) {
+    if (cause &&
+        isObject(cause) &&
+        cause.code === COMPILER_ERROR_CODE) {
+        return cause;
+    }
     const error = new Error(message);
     error.name = "CompilerError";
-    error.code = "COMPILER_ERROR";
+    error.code = COMPILER_ERROR_CODE;
     error.category = "wasm";
     error.exitCode = 1;
-    if (cause) {
+    if (cause || details) {
+        const inheritedDetails = cause && isObject(cause.details)
+            ? cause.details
+            : undefined;
         error.details = {
-            cause: cause.message,
-            stack: cause.stack,
+            ...(inheritedDetails || {}),
+            ...(details || {}),
+            ...(cause
+                ? {
+                    cause: cause.message,
+                    stack: cause.stack,
+                }
+                : {}),
         };
     }
     return error;
 }
+export function extractFormattedErrors(result) {
+    const terminal = readStringMethod(result, "get_formatted_errors_terminal") ||
+        readStringProperty(result, "formattedErrorsTerminal") ||
+        readStringProperty(result, "formatted_errors_terminal") ||
+        readStringMethod(result, "format_all_terminal");
+    const json = readStringMethod(result, "format_all_json") ||
+        readStringMethod(result, "get_formatted_errors_json") ||
+        readStringProperty(result, "formattedErrorsJson") ||
+        readStringProperty(result, "formatted_errors_json");
+    return { terminal, json };
+}
+export function normalizeDiagnostic(error) {
+    let parsedJson;
+    if (error && typeof error?.format_json === "function") {
+        try {
+            const raw = error.format_json();
+            const parsed = JSON.parse(raw);
+            if (isObject(parsed)) {
+                parsedJson = parsed;
+            }
+        }
+        catch {
+            // Ignore formatter/parsing failures and continue with direct field access.
+        }
+    }
+    const merged = {
+        ...(parsedJson || {}),
+        ...(isObject(error) ? error : {}),
+    };
+    const location = isObject(merged.location) ? merged.location : undefined;
+    const line = toOptionalNumber(merged.line) ?? toOptionalNumber(location?.line);
+    const column = toOptionalNumber(merged.column) ?? toOptionalNumber(location?.column);
+    const file = toOptionalString(merged.sourceLocation) ??
+        toOptionalString(location?.file);
+    const code = toOptionalString(merged.code) || "E0000";
+    const suggestionList = pickSuggestions(merged.suggestions) || buildFallbackSuggestions(code);
+    const rendered = toOptionalString(merged.rendered) ||
+        (typeof merged.format_terminal === "function"
+            ? toOptionalString(merged.format_terminal())
+            : undefined);
+    return {
+        type: toOptionalString(merged.type) || "enhanced",
+        code,
+        severity: toOptionalString(merged.severity) || "error",
+        category: toOptionalString(merged.category) || "compilation",
+        message: toOptionalString(merged.message) ||
+            toOptionalString(merged.description) ||
+            "Unknown compiler error",
+        description: toOptionalString(merged.description),
+        line,
+        column,
+        sourceLocation: file,
+        location,
+        suggestion: suggestionList?.[0]?.message,
+        suggestions: suggestionList,
+        sourceLine: toOptionalString(merged.source_line) ||
+            toOptionalString(merged.sourceLine),
+        sourceSnippet: toOptionalString(merged.source_snippet) ||
+            toOptionalString(merged.sourceSnippet),
+        rendered,
+        raw: error,
+    };
+}
+function parseDiagnosticsJson(jsonPayload, logger) {
+    try {
+        const parsed = JSON.parse(jsonPayload);
+        const arr = Array.isArray(parsed)
+            ? parsed
+            : Array.isArray(parsed?.errors)
+                ? parsed.errors
+                : [];
+        return arr.map((item) => normalizeDiagnostic(item));
+    }
+    catch (error) {
+        logger?.debug?.("[Compilation] Failed to parse formatted JSON diagnostics", error);
+        return [];
+    }
+}
+export function extractDiagnostics(result, logger) {
+    const formatted = extractFormattedErrors(result);
+    if (formatted.json) {
+        const parsed = parseDiagnosticsJson(formatted.json, logger);
+        if (parsed.length > 0) {
+            return parsed;
+        }
+    }
+    if (Array.isArray(result?.compiler_errors)) {
+        const fromCompiler = result.compiler_errors.map((item) => normalizeDiagnostic(item));
+        if (fromCompiler.length > 0) {
+            return fromCompiler;
+        }
+    }
+    if (Array.isArray(result?.errors)) {
+        const fromErrors = result.errors.map((item) => normalizeDiagnostic(item));
+        if (fromErrors.length > 0) {
+            return fromErrors;
+        }
+    }
+    return [];
+}
 export function extractMetrics(result, defaultFormat) {
     if (!result || typeof result !== "object") {
         return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@5ive-tech/sdk",
-  "version": "1.1.10",
+  "version": "1.1.13",
   "description": "Client-agnostic TypeScript SDK for Five VM scripts on Solana",
   "type": "module",
   "main": "dist/index.js",
@@ -34,7 +34,8 @@
     "sync:wasm:rebuild": "bash ../scripts/sync-wasm-assets.sh --rebuild",
     "verify:wasm": "bash ../scripts/verify-wasm-sync.sh",
     "copy-assets": "mkdir -p dist/assets/vm && COPYFILE_DISABLE=1 cp src/assets/vm/* dist/assets/vm/",
-    "test": "node examples/basic-usage.js",
+    "test": "npm run test:jest --",
+    "test:example": "node src/examples/basic-usage.js",
     "test:jest": "NODE_OPTIONS=--experimental-vm-modules jest --runInBand",
     "test:localnet": "USE_SOLANA_MOCKS=0 RUN_LOCALNET_VALIDATOR_TESTS=1 NODE_OPTIONS=--experimental-vm-modules jest --runInBand src/__tests__/integration/localnet-fee-vault.test.ts",
     "gen-types": "node ./node_modules/typescript/bin/tsc && node dist/bin/gen-types.js",
@@ -57,4 +58,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}