@preference-sl/pref-configurator-sdk 0.1.0-beta.1

package/js/gltf-storage.js

@@ -0,0 +1,239 @@
+// wwwroot/js/gltf-storage.js
+
+// Public, inspectable namespace
+const PC = (globalThis.PrefConfigurator ??= {});
+PC.version = PC.version ?? "1.0.1"; // bump if your schema changes!!
+PC.db = PC.db ?? null;
+PC.dbName = PC.dbName ?? null;
+PC.storeName = PC.storeName ?? null;
+
+function _getDbOrThrow() {
+    const db = PC.db;
+    if (!db) throw new Error("Database not initialized. Call initDb(...) first.");
+    return db;
+}
+
+// --- internal helpers -------------------------------------------------------
+function _openEnsuringStore(dbName, storeName) {
+    return new Promise((resolve, reject) => {
+        const open = indexedDB.open(dbName, 5);
+
+        open.onblocked = () => reject(new Error("Open blocked by another tab or worker"));
+        open.onerror = () => reject(open.error);
+        open.onsuccess = (e) => {
+            resolve(e.target.result);
+        }
+        open.onupgradeneeded = (ev) => {
+            const upgradeDb = ev.target.result;
+            const tx = ev.target.transaction;
+
+            let store;
+            if (!upgradeDb.objectStoreNames.contains(storeName)) {
+                store = upgradeDb.createObjectStore(storeName, { keyPath: 'id' });
+            } else if (tx) {
+                store = tx.objectStore(storeName);
+            }
+
+            if (store && !store.indexNames.contains('expirationTimeStamp')) {
+                store.createIndex('expirationTimeStamp', 'expirationTimeStamp', { unique: false });
+            }
+        };
+    });
+}
+
+function _isRecoverableDbError(err) {
+    const msg = String(err?.message ?? err ?? "");
+    if (!msg) return false;
+    return msg.includes("Database not initialized") ||
+        msg.includes("The database connection is closing") ||
+        msg.includes("InvalidStateError") ||
+        msg.includes("NotFoundError");
+}
+
+async function _withDbRetry(work) {
+    try {
+        return await work(_getDbOrThrow());
+    } catch (e) {
+        if (!_isRecoverableDbError(e) || !PC.dbName || !PC.storeName) {
+            throw e;
+        }
+        await initDb(PC.dbName, PC.storeName);
+        return await work(_getDbOrThrow());
+    }
+}
+
+// --- public API -------------------------------------------------------------
+
+// Inicializar IndexedDB y dejar el handle en PrefConfigurator.db (público)
+export async function initDb(dbName, storeName) {
+    PC.dbName = dbName;
+    PC.storeName = storeName;
+
+    const db = await _openEnsuringStore(dbName, storeName);
+    // Close any previous handle to avoid versionchange blocking
+    try { PC.db?.close?.(); } catch { }
+    PC.db = db;
+
+    // If another tab upgrades, close gracefully so next call can re-init
+    db.onversionchange = () => {
+        try { db.close(); } catch { }
+        if (PC.db === db) PC.db = null;
+        console.warn("[PrefConfigurator] DB connection closed due to versionchange. Re-run initDb().");
+    };
+}
+
+// Guardar modelo
+export async function saveModel(modelDataStr, storeName) {
+    return _withDbRetry((db) => new Promise((resolve, reject) => {
+        let modelData;
+        try { modelData = JSON.parse(modelDataStr); }
+        catch (e) { reject(new Error("saveModel: modelDataStr is not valid JSON")); return; }
+
+        const dataToStore = {
+            ...modelData,
+            data: modelData.data,
+            size: (modelData?.data?.length ?? 0)
+        };
+
+        const tx = db.transaction([storeName], "readwrite");
+        const store = tx.objectStore(storeName);
+        const req = store.put(dataToStore);
+
+        req.onerror = () => reject(req.error);
+        req.onsuccess = () => resolve();
+    }));
+}
+
+// Cargar modelo
+export function loadModel(modelId, storeName) {
+    return _withDbRetry((db) => new Promise((resolve, reject) => {
+        const tx = db.transaction([storeName], "readonly");
+        const store = tx.objectStore(storeName);
+        const req = store.get(modelId);
+
+        req.onerror = () => reject(req.error);
+        req.onsuccess = () => resolve(req.result ?? null);
+    }));
+}
+
+// Descargar archivo desde base64
+export function downloadFileFromBytes(fileName, bytesBase64, mimeType) {
+    const link = document.createElement("a");
+    link.download = fileName;
+    link.href = `data:${mimeType};base64,${bytesBase64}`;
+    document.body.appendChild(link);
+    link.click();
+    link.remove();
+}
+
+// Obtener todos los modelos (solo metadata)
+export async function getAllModels(storeName) {
+    return _withDbRetry((db) => new Promise((resolve, reject) => {
+        const tx = db.transaction([storeName], "readonly");
+        const store = tx.objectStore(storeName);
+        const req = store.getAll();
+
+        req.onerror = () => reject(req.error);
+        req.onsuccess = () => {
+            const items = Array.isArray(req.result) ? req.result : [];
+            const results = items.map(item => ({
+                id: item.id,
+                metadata: item.metadata,
+                timeStamp: item.timeStamp,
+                size: item.size
+            }));
+            // keep old behavior: return JSON string
+            resolve(JSON.stringify(results));
+        };
+    }));
+}
+
+// Eliminar modelo por id
+export async function deleteModel(modelId, storeName) {
+    return _withDbRetry((db) => new Promise((resolve, reject) => {
+        const tx = db.transaction([storeName], "readwrite");
+        const store = tx.objectStore(storeName);
+        const req = store.delete(modelId);
+
+        req.onerror = () => reject(req.error);
+        req.onsuccess = () => resolve();
+    }));
+}
+
+// Limpiar toda la store
+export async function clearAll(storeName) {
+    return _withDbRetry((db) => new Promise((resolve, reject) => {
+        const tx = db.transaction([storeName], "readwrite");
+        const store = tx.objectStore(storeName);
+        const req = store.clear();
+
+        req.onerror = () => reject(req.error);
+        req.onsuccess = () => resolve();
+    }));
+}
+
+// Borrar modelos expirados usando el índice "expirationTimeStamp"
+export async function cleanExpiredModels(storeName) {
+    return _withDbRetry((db) => new Promise((resolve, reject) => {
+        const tx = db.transaction([storeName], "readwrite");
+        const store = tx.objectStore(storeName);
+
+        const index = store.index("expirationTimeStamp");
+        const now = Date.now();
+        const range = IDBKeyRange.upperBound(now);
+        const cursorRequest = index.openCursor(range);
+
+        cursorRequest.onerror = () => reject(cursorRequest.error);
+        cursorRequest.onsuccess = (event) => {
+            const cursor = event.target.result;
+            if (cursor) {
+                cursor.delete();
+                cursor.continue();
+            }
+        };
+
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    }));
+}
+
+// Utilidades opcionales y visibles (por si las quieres usar en consola)
+export function closeDb() {
+    if (PC.db) {
+        try { PC.db.close(); } catch { }
+        PC.db = null;
+    }
+}
+
+export function deleteDatabase(dbName) {
+    return new Promise((resolve, reject) => {
+        // Close current handle if points to this DB
+        if (PC.db && PC.db.name === dbName) {
+            try { PC.db.close(); } catch { }
+            PC.db = null;
+        }
+        const req = indexedDB.deleteDatabase(dbName);
+        req.onblocked = () => reject(new Error("Delete blocked by another tab or worker"));
+        req.onerror = () => reject(req.error);
+        req.onsuccess = () => resolve();
+    });
+}
+
+// Attach a frozen, public API (no private state)
+(function attachPublicAPI(global) {
+    const storage = {
+        initDb,
+        saveModel,
+        loadModel,
+        getAllModels,
+        deleteModel,
+        clearAll,
+        cleanExpiredModels,
+        downloadFileFromBytes,
+        // extras
+        closeDb,
+        deleteDatabase,
+    };
+    // free to inspect PC.db in devtools
+    global.PrefConfigurator.storage = Object.freeze(storage);
+})(globalThis);

package/js/prefconfigurator-api.d.ts

@@ -0,0 +1,380 @@
+export interface ErrorInfo {
+    Code?: string;
+    Message?: string;
+    Source?: string;
+    HttpStatus?: number;
+    RequestId?: string;
+    CorrelationId?: string;
+    TraceParent?: string;
+    Detail?: string;
+}
+
+export interface OperationResult<T> {
+    Ok: boolean;
+    Data?: T | null;
+    Error?: ErrorInfo | null;
+    CallId?: string | null;
+}
+
+export interface CreateItemResponse {
+    ItemId: string;
+}
+
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
+
+export interface OptionValueInfo {
+    ValueString?: string | null;
+    ValueNumeric?: number | null;
+    Hidden: boolean;
+}
+
+export interface OptionInfo {
+    Maker?: string | null;
+    Code?: string | null;
+    Type?: string | null;
+    Context?: string | null;
+    Description?: string | null;
+    ValueString?: string | null;
+    ValueNumeric?: number | null;
+    Hidden: boolean;
+    DefaultValueDefined: boolean;
+    Values?: OptionValueInfo[] | null;
+}
+
+export interface OptionList {
+    Name?: string | null;
+    Childs?: OptionList[] | null;
+    Options?: OptionInfo[] | null;
+}
+
+export type OptionLocation = { [key: string]: JsonValue };
+
+export interface EnhancedOptionInfo extends OptionInfo {
+    PartitionPart?: string | null;
+    ValueChanged: boolean;
+    Locations?: OptionLocation[] | null;
+}
+
+export interface EnhancedOptionList {
+    Name?: string | null;
+    Childs?: EnhancedOptionList[] | null;
+    Options?: EnhancedOptionInfo[] | null;
+}
+
+export interface DimensionsResponse {
+    TotalL?: number | null;
+    TotalA?: number | null;
+    Values?: Record<string, number>;
+    ValuesText?: Record<string, string>;
+    LLabels?: string[];
+    ALabels?: string[];
+    LCount?: number;
+    ACount?: number;
+}
+
+export interface SetDimensionsResponse {
+    RawResults?: Array<boolean | null>;
+    Succeeded?: boolean | null;
+    Status?: string | null;
+    Message?: string | null;
+}
+
+export interface SetDimensionValueRequest {
+    dimensionName: string;
+    dimensionValue: number;
+}
+
+export interface SetOptionValueResponse {
+    succeeded: boolean;
+    status?: string | null;
+    message?: string | null;
+    optionChanged?: boolean | null;
+}
+
+export interface SetOptionValueRequest {
+    optionName: string;
+    optionValue: string;
+}
+
+export interface SetOptionValueBatchResult {
+    optionName: string;
+    sent: boolean;
+    reason?: string | null;
+    response?: SetOptionValueResponse | null;
+}
+
+export interface SetOptionsResponse {
+    requestedCount: number;
+    sentCount: number;
+    skippedCount: number;
+    results: SetOptionValueBatchResult[];
+}
+
+export interface SceneTexCoord {
+    Scale: number[];
+    Offset: number[];
+}
+
+export interface ScenePlane {
+    Normal: number[];
+    Point: number[];
+}
+
+export interface SceneFloor {
+    Plane: ScenePlane;
+    TexCoord: SceneTexCoord;
+}
+
+export interface SceneMaterial {
+    Name: string;
+    BaseColor: string;
+    Roughness: string;
+    Normal: string;
+}
+
+export interface SceneWallData {
+    OuterWallTexCoord: SceneTexCoord;
+    InnerWallTexCoord: SceneTexCoord;
+    OuterFloor: SceneFloor;
+    InnerFloor: SceneFloor;
+    WallPolyline: string;
+    MinWallThickness: number;
+    Translation: number[];
+    FloorPath: string;
+    UpAxis: number;
+    RotationAngle: number;
+    Materials: SceneMaterial[];
+    InnerHeight?: number | null;
+    OuterHeight?: number | null;
+    ExtraInnerWallDepth?: number | null;
+}
+
+export interface Scene {
+    Maker: string;
+    Name: string;
+    Format: string;
+    Uri: string;
+    ConfigFile: string;
+    HdrFile: string;
+    DbMaterialsId: string;
+    WallDatas: SceneWallData[];
+}
+
+export interface EnvJson {
+    version?: number | null;
+
+    services: {
+        baseUrl?: string | null;
+        serviceMappings?: Array<{ serviceName: string; kind: "path" | "port"; value: string }> | null;
+        urlResolutionMode?: "legacy" | "explicit" | null;
+        hydraBaseUrl?: string | null;
+        prefWebBaseUrl?: string | null;
+        kbApiBaseUrl?: string | null;
+        hcApiBaseUrl?: string | null;
+        hypercubeId?: string | null;
+        hypercubeDeploymentId?: string | null;
+        cloudPrefWebBaseUrl?: string | null;
+        kbUiBaseUrl?: string | null;
+        wallGeneratorBaseUrl?: string | null;
+        usdBaseUrl?: string | null;
+    };
+
+    maker: {
+        name?: string | null;
+        prefix?: string | null;
+        environment?: string | null;
+    };
+
+    ui: {
+        definitionName?: string | null;
+        optionListName?: string | null;
+    };
+
+    auth: {
+        username?: string | null;
+        password?: string | null;
+    };
+
+    images: {
+        model: {
+            onlyModelImage: boolean;
+            type2D: number;
+            type3D: number;
+            width: number;
+            height: number;
+            daysToLive: number;
+        };
+        scene: {
+            name: string;
+            format: string;
+        };
+        materials: {
+            daysToLive: number;
+        };
+        usd?: {
+            sceneName?: string | null;
+            generateWall?: boolean | null;
+            qualities?: string[] | null;
+            resolutions?: string[] | null;
+            cameras?: string[] | null;
+            imageFormat?: string | null;
+            variantSets?: UsdVariantSet[] | null;
+        };
+    };
+
+    storage: {
+        gltf: {
+            dbName: string;
+            storeName: string;
+        };
+    };
+
+    runtime: {
+        logLevel: string;
+        httpTimeoutSeconds?: number | null;
+    };
+
+    flags?: Record<string, boolean> | null;
+    extra?: Record<string, any | null> | null;
+}
+
+export enum ViewMode {
+    _0,
+    _1,
+    _2,
+    _3
+}
+
+export enum ImageType {
+    _0,
+    _1,
+    _2,
+    _3,
+    _4,
+    _5,
+    _6,
+    _7,
+    _8,
+    _9,
+    _10,
+    _11,
+    _12,
+    _13,
+    _14,
+    _15,
+    _16,
+    _17
+}
+
+export interface CadRendererData {
+    viewMode: ViewMode;
+    cameraProjection?: number | null;
+    cameraPosition?: number | null;
+    predefinedView?: string | null;
+    backgroundColor?: number | null;
+    customProperties?: string | null;
+    texturesRootPath?: string | null;
+    base64Textures?: boolean | null;
+}
+
+export interface ModelImageConfig {
+    imageType: ImageType;
+    width: number;
+    height: number;
+    useHypercube?: boolean | null;
+    hcGenerate?: boolean | null;
+    hcWait?: boolean | null;
+    units: number;
+    usePrefOne: boolean;
+    languageId: number;
+    visualPropertiesXML?: string | null;
+    cadRenderer?: CadRendererData | null;
+}
+
+export interface UsdVariantSet {
+    name: string;
+    selection: string;
+}
+
+export interface HcProductStatusResult {
+    available: boolean;
+    href?: string | null;
+    status?: string | null;
+    productHash?: string | null;
+}
+
+export interface UsdImagesModel {
+    itemId: string;
+    generateWall?: boolean | null;
+}
+
+export interface UsdImagesRequest {
+    sceneName?: string | null;
+    useHypercube?: boolean | null;
+    hcGenerate?: boolean | null;
+    hcWait?: boolean | null;
+    models?: UsdImagesModel[] | null;
+    qualities?: string[] | null;
+    resolutions?: string[] | null;
+    cameras?: string[] | null;
+    imageFormat?: string | null;
+    variantSets?: UsdVariantSet[] | null;
+    renderMode?: string | null;
+    visualProperties?: string | null;
+}
+
+export interface JsInteropApiRaw {
+    InitializeFromEnvJson(json: string): void;
+
+    GetOptions<T = EnhancedOptionList>(): Promise<OperationResult<T> | string>;
+    UpdateOptions<T = EnhancedOptionList>(optionListJson: string, optionNamesChangedJson: string): Promise<OperationResult<T> | string>;
+    CreateItem<T = CreateItemResponse>(modelCode: string, isPersistable: boolean): Promise<OperationResult<T> | string>;
+    GetDimensions<T = DimensionsResponse>(modelId: string): Promise<OperationResult<T> | string>;
+    SetDimensions<T = SetDimensionsResponse>(modelId: string, dimensions: SetDimensionValueRequest[]): Promise<OperationResult<T> | string>;
+    SetOptions<T = SetOptionsResponse>(modelId: string, options: SetOptionValueRequest[]): Promise<OperationResult<T> | string>;
+    GetModelOptions<T = OptionInfo[]>(modelId: string): Promise<OperationResult<T> | string>;
+    GetScene<T = Scene>(sceneName?: string, sceneFormat?: string, texturesRootPath?: string): Promise<OperationResult<T> | string>;
+    GetModelImage(modelId: string, modelImageConfigJson: string, sceneName?: string, optionListJson?: string): Promise<OperationResult<string> | string>;
+    GetUsdImages<T = string[]>(usdImagesRequestJson: string, optionListJson?: string): Promise<OperationResult<T> | string>;
+    GetUsdImagesHcStatus<T = HcProductStatusResult[]>(usdImagesRequestJson: string, optionListJson: string): Promise<OperationResult<T> | string>;
+    GetModelImageHcStatus<T = HcProductStatusResult>(modelId: string, modelImageConfigJson: string): Promise<OperationResult<T> | string>;
+    GetDefaultMaker(): string;
+    GetMakerPrefix(): string;
+    GetUiDefinitionName(): string;
+    GetOptionListName(): string;
+    GetBaseUrl(): string;
+    GetUsername(): string;
+    GetPassword(): string;
+    GetSceneName(): string;
+    GetSceneFormat(): string;
+    GetTextureRootPath(): string;
+
+    [key: string]: unknown;
+}
+
+export type RawOperation<T = JsonValue> = OperationResult<T> | string | null | undefined;
+
+export function parse<T = JsonValue>(raw: RawOperation<T>): OperationResult<T>;
+
+export function ensureOk<T = JsonValue>(raw: RawOperation<T>): T;
+
+type AwaitedReturn<T> = T extends Promise<infer R> ? R : T;
+type ExtractData<R> = AwaitedReturn<R> extends OperationResult<infer D> ? D : JsonValue;
+type BoundMethod<F> = F extends (...args: infer A) => Promise<infer R> ? (...args: A) => Promise<ExtractData<R>> : F;
+
+// BOUND API — PUBLIC API CORRECTLY TYPED
+
+export type BoundApi<TRaw extends JsInteropApiRaw> = { [K in keyof TRaw]: TRaw[K] extends Function ? BoundMethod<TRaw[K]> : TRaw[K];
+} & {
+    InitializeFromEnvJson(config: EnvJson): void;
+    UpdateOptions(optionList: OptionList, changedOptionNames: string[]): Promise<EnhancedOptionList>;
+    SetDimensions(modelId: string, updates: SetDimensionValueRequest[]): Promise<SetDimensionsResponse>;
+    SetOptions(modelId: string, updates: SetOptionValueRequest[]): Promise<SetOptionsResponse>;
+    GetModelImage(modelId: string, config: ModelImageConfig, sceneName?: string, optionList?: OptionList): Promise<string>;
+    GetUsdImages(request: UsdImagesRequest, optionList?: OptionList): Promise<string[]>;
+    GetUsdImagesHcStatus(request: UsdImagesRequest, optionList: OptionList): Promise<HcProductStatusResult[]>;
+    GetModelImageHcStatus(modelId: string, config: ModelImageConfig): Promise<HcProductStatusResult>;
+};
+
+export function bindApi<TRaw extends JsInteropApiRaw>(rawApi: TRaw): BoundApi<TRaw>;

package/js/prefconfigurator-api.js

@@ -0,0 +1,44 @@
+// Helper utilities to deal with the OperationResult envelope returned by the WASM interop.
+// - ensureOk(raw) -> returns the data payload or throws an Error enriched with error codes and callId.
+// - bindApi(exportsAsm.PrefConfigurator.Wasm.JsInteropApi) -> proxy that auto-unwraps data for you.
+
+export function parse(raw) {
+    if (raw === undefined || raw === null || raw === "") throw new Error("Empty response from WASM interop.");
+    if (typeof raw === "string") {
+        try {
+            return JSON.parse(raw);
+        } catch (e) {
+            throw new Error("Malformed JSON from WASM interop.");
+        }
+    }
+    return raw;
+}
+
+export function ensureOk(raw) {
+    const res = parse(raw);
+    const ok = res?.Ok;
+    if (ok) return res?.Data ?? null;
+
+    const errObj = res?.Error;
+    const err = new Error(errObj?.Message ?? "Operation failed.");
+    err.code = errObj?.Code;
+    err.source = errObj?.Source;
+    err.httpStatus = errObj?.HttpStatus;
+    err.requestId = errObj?.RequestId;
+    err.correlationId = errObj?.CorrelationId;
+    err.traceParent = errObj?.TraceParent;
+    err.detail = errObj?.Detail;
+    err.callId = res?.CallId;
+    err.result = res;
+    throw err;
+}
+
+export function bindApi(rawApi) {
+    return new Proxy(rawApi, {
+        get(target, prop) {
+            const value = target[prop];
+            if (typeof value !== "function") return value;
+            return async (...args) => ensureOk(await value(...args));
+        }
+    });
+}

package/main.d.ts

@@ -0,0 +1,4 @@
+declare const runtimeInfo: {
+  frameworkPath: string;
+};
+export = runtimeInfo;

package/main.js

@@ -0,0 +1,2 @@
+const path = require("path");
+module.exports = { frameworkPath: path.join(__dirname, "_framework") };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "private": false,
+  "files": [
+    "_framework/**",
+    "**/*.js",
+    "**/*.d.ts",
+    "**/*.wasm",
+    "index.html",
+    "README.md"
+  ],
+  "description": ".NET WebAssembly SDK that embeds Preference's business logic for building product configurators (windows, doors, joinery) in browser-based ecommerce platforms.",
+  "author": "Alex Moreno Palacio <amoreno@preference.es>",
+  "types": "main.d.ts",
+  "version": "0.1.0-beta.1",
+  "license": "MIT",
+  "name": "@preference-sl/pref-configurator-sdk",
+  "exports": {
+    "./js/prefconfigurator-api": {
+      "types": "./js/prefconfigurator-api.d.ts",
+      "default": "./js/prefconfigurator-api.js"
+    },
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./main.d.ts",
+      "default": "./main.js"
+    },
+    "./index.html": "./index.html"
+  },
+  "main": "main.js",
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  }
+}