@e-llm-studio/feedback-flow 0.0.0-stage → 0.1.31

package/dist/httpFeedbackApi.js

@@ -0,0 +1,390 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpFeedbackApi = createHttpFeedbackApi;
+const PATH = "/segment_click_analytics/v1/feedback";
+const UUID4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const SERVER_IDS_KEY = "__feedback_api_server_nested_ids";
+const memoryRecords = new Map();
+const readCache = new Map();
+const READ_CACHE_MS = 30000;
+function storageKey(baseUrl, lookup) {
+    return `@e-llm-studio/feedback-flow/http/v1:${baseUrl}:${lookup.query_id}:${lookup.feature_id}:${lookup.user_email ?? ""}`;
+}
+function readSaved(baseUrl, lookup) {
+    const key = storageKey(baseUrl, lookup);
+    try {
+        const stored = globalThis.localStorage?.getItem(key);
+        if (stored)
+            return JSON.parse(stored);
+    }
+    catch {
+        /* private browsing uses memory */
+    }
+    return memoryRecords.get(key) ?? null;
+}
+function writeSaved(baseUrl, record) {
+    const form = record.feedback_form;
+    const key = storageKey(baseUrl, { query_id: form.query_id, feature_id: form.feature_id, user_email: form.user_email });
+    memoryRecords.set(key, record);
+    try {
+        globalThis.localStorage?.setItem(key, JSON.stringify(record));
+    }
+    catch {
+        /* private browsing uses memory */
+    }
+    return record;
+}
+function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function remoteRecord(value, lookup) {
+    const data = asObject(value);
+    const metadata = asObject(data.form_metadata ?? data.metadata);
+    const feedbackId = String(data.feedback_id);
+    const createdAt = typeof data.created_at === "string" ? data.created_at : new Date().toISOString();
+    const positives = Array.isArray(data.positive_feedback) ? data.positive_feedback : [];
+    const negatives = Array.isArray(data.negative_feedback) ? data.negative_feedback : [];
+    const positiveIds = positives.map((item) => String(asObject(item).positive_id ?? ""));
+    const negativeIds = negatives.map((item) => String(asObject(item).negative_id ?? ""));
+    const attachments = [];
+    const collectAttachments = (item, parentId, kind) => {
+        const entry = asObject(item);
+        for (const raw of Array.isArray(entry.attachments) ? entry.attachments : []) {
+            const attachment = asObject(raw);
+            if (typeof attachment.gcs_url !== "string")
+                continue;
+            const attachmentMetadata = asObject(attachment.metadata);
+            attachments.push({
+                attachment_id: String(attachment.attachment_id ?? attachment.gcs_url),
+                [kind]: parentId,
+                gcs_url: attachment.gcs_url,
+                metadata: {
+                    ...attachmentMetadata,
+                    file_name: String(attachmentMetadata.file_name ?? attachment.gcs_url.split("/").pop() ?? "Screenshot"),
+                },
+                created_at: typeof attachment.created_at === "string" ? attachment.created_at : createdAt,
+            });
+        }
+    };
+    positives.forEach((item, index) => collectAttachments(item, positiveIds[index], "positive_id"));
+    negatives.forEach((item, index) => collectAttachments(item, negativeIds[index], "negative_id"));
+    return {
+        feedback_form: {
+            feedback_id: feedbackId,
+            query_id: lookup.query_id,
+            feature_id: lookup.feature_id,
+            user_email: lookup.user_email ?? "",
+            rating: Number(data.rating),
+            trace_id: typeof data.trace_id === "string" ? data.trace_id : undefined,
+            session_id: typeof data.session_id === "string" ? data.session_id : lookup.session_id,
+            request_id: typeof data.request_id === "string" ? data.request_id : lookup.request_id,
+            metadata: {
+                ...metadata,
+                userEmail: lookup.user_email ?? data.user_email ?? metadata.userEmail,
+                ...(lookup.is_ai_query ? { queryId: lookup.query_id } : {}),
+                sessionId: typeof data.session_id === "string" ? data.session_id : lookup.session_id ?? metadata.sessionId,
+                requestId: typeof data.request_id === "string" ? data.request_id : lookup.request_id ?? metadata.requestId,
+                source_request_id: lookup.source_request_id ?? metadata.source_request_id,
+                [SERVER_IDS_KEY]: { positive: positiveIds, negative: negativeIds },
+            },
+            created_at: createdAt,
+        },
+        positive_feedback: positives.map((raw, index) => {
+            const item = asObject(raw);
+            return {
+                feedback_id: feedbackId,
+                positive_id: positiveIds[index],
+                description: String(item.description ?? ""),
+                time_saved_mins: typeof item.time_saved_mins === "number" ? item.time_saved_mins : undefined,
+                metadata: asObject(item.metadata),
+                created_at: typeof item.created_at === "string" ? item.created_at : createdAt,
+            };
+        }),
+        gaps: negatives.map((raw, index) => {
+            const item = asObject(raw);
+            return {
+                feedback_id: feedbackId,
+                negative_id: negativeIds[index],
+                description: String(item.description ?? ""),
+                severity: typeof item.severity === "string" ? item.severity.toLowerCase() : undefined,
+                metadata: asObject(item.metadata),
+                created_at: typeof item.created_at === "string" ? item.created_at : createdAt,
+            };
+        }),
+        feedback_attachment: attachments,
+    };
+}
+// Preserve an identity across reloads when a host's response ID is not a UUID.
+function stableFeatureUuid(value) {
+    const hashes = [2166136261, 2166136261 ^ 0x9e3779b9, 2166136261 ^ 0x85ebca6b, 2166136261 ^ 0xc2b2ae35];
+    for (const char of value)
+        for (let i = 0; i < hashes.length; i += 1) {
+            hashes[i] = Math.imul(hashes[i] ^ char.charCodeAt(0), 16777619);
+        }
+    const bytes = hashes.flatMap((hash) => [hash >>> 24, hash >>> 16, hash >>> 8, hash].map((part) => part & 255));
+    bytes[6] = (bytes[6] & 15) | 64;
+    bytes[8] = (bytes[8] & 63) | 128;
+    const hex = bytes.map((byte) => byte.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function feedbackIdentity(queryId, featureId, isAiQuery) {
+    if (isAiQuery)
+        return { query_id: queryId };
+    if (UUID4.test(featureId))
+        return { feature_id: featureId };
+    return { feature_id: stableFeatureUuid(`${featureId}:${queryId}`) };
+}
+function requestPayload(record, update) {
+    const form = record.feedback_form;
+    const { [SERVER_IDS_KEY]: serverIdsValue, requestId: _requestId, queryId: _queryId, sessionId: _sessionId, source_request_id: _sourceRequestId, ...publicMetadata } = form.metadata;
+    const serverIds = (serverIdsValue && typeof serverIdsValue === "object" ? serverIdsValue : {});
+    if (form.session_id && !form.metadata.queryId?.trim()) {
+        throw new Error("Chat feedback requires a query_id before it can be saved");
+    }
+    const identity = feedbackIdentity(form.query_id, form.feature_id, Boolean(form.session_id));
+    return {
+        ...identity,
+        ...(!update ? { user_email: form.user_email } : {}),
+        ...(form.session_id ? { session_id: form.session_id } : {}),
+        ...(form.request_id ? { request_id: form.request_id } : {}),
+        rating: form.rating,
+        trace_id: form.trace_id,
+        metadata: {
+            ...publicMetadata,
+            ...(form.session_id ? { source_query_id: form.query_id } : {}),
+            source_feature_id: form.feature_id,
+        },
+        positive_feedback: record.positive_feedback.map((item) => ({
+            ...(update && serverIds.positive?.includes(item.positive_id) ? { positive_id: item.positive_id } : {}),
+            description: item.description,
+            time_saved_mins: item.time_saved_mins,
+            metadata: item.metadata,
+            ...(!update ? { attachments: [] } : {}),
+        })),
+        negative_feedback: record.gaps.map((gap) => ({
+            ...(update && serverIds.negative?.includes(gap.negative_id) ? { negative_id: gap.negative_id } : {}),
+            description: gap.description,
+            severity: gap.severity ? gap.severity[0].toUpperCase() + gap.severity.slice(1) : undefined,
+            metadata: gap.metadata,
+            attachments: record.feedback_attachment
+                .filter((attachment) => attachment.negative_id === gap.negative_id)
+                .map((attachment) => ({ gcs_url: attachment.gcs_url, metadata: attachment.metadata })),
+        })),
+    };
+}
+function feedbackId(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const data = value;
+    if (typeof data.feedback_id === "string")
+        return data.feedback_id;
+    return feedbackId(data.data ?? data.responseData);
+}
+function nestedServerIds(value) {
+    if (!value || typeof value !== "object")
+        return {};
+    const data = value;
+    if (data.data || data.responseData)
+        return nestedServerIds(data.data ?? data.responseData);
+    const ids = (key, id) => Array.isArray(data[key])
+        ? data[key]
+            .map((item) => (item && typeof item === "object" ? item[id] : undefined))
+            .map((item) => (typeof item === "string" && UUID4.test(item) ? item : ""))
+        : undefined;
+    return { positive: ids("positive_feedback", "positive_id"), negative: ids("negative_feedback", "negative_id") };
+}
+/** GET restores saved feedback; POST creates and PUT updates it. */
+function createHttpFeedbackApi(options) {
+    const fetcher = options.fetcher ?? fetch;
+    const endpoint = `${options.baseUrl.replace(/\/$/, "")}${PATH}`;
+    const readEndpoint = `${(options.readBaseUrl ?? options.baseUrl).replace(/\/$/, "")}${PATH}`;
+    const authHeaders = () => {
+        const token = options.getAuthToken?.();
+        return token ? { Authorization: `Bearer ${token}` } : {};
+    };
+    const fetchSavedById = async (form) => {
+        const url = new URL(readEndpoint);
+        url.searchParams.set("user_email", form.user_email);
+        if (form.session_id)
+            url.searchParams.set("session_id", form.session_id);
+        else {
+            const identity = feedbackIdentity(form.query_id, form.feature_id, false);
+            url.searchParams.set("feature_id", "feature_id" in identity ? identity.feature_id : form.feature_id);
+        }
+        const response = await fetcher(url.toString(), { headers: { accept: "application/json", ...authHeaders() } });
+        if (!response.ok)
+            throw new Error(`Feedback identity lookup failed (${response.status})`);
+        const body = asObject(await response.json());
+        const row = (Array.isArray(body.data) ? body.data : []).find((item) => asObject(item).feedback_id === form.feedback_id);
+        return row ? remoteRecord(row, {
+            query_id: form.query_id,
+            feature_id: form.feature_id,
+            user_email: form.user_email,
+            session_id: form.session_id,
+            request_id: form.request_id,
+            source_request_id: form.metadata.source_request_id,
+            is_ai_query: Boolean(form.session_id),
+        }) : null;
+    };
+    return {
+        uploadAttachment: options.uploadAttachment,
+        getAttachmentPreviewUrl: options.getAttachmentPreviewUrl,
+        async getFeedback(lookup) {
+            if (!lookup.user_email || (!lookup.feature_id && !lookup.session_id))
+                return readSaved(options.baseUrl, lookup);
+            const url = new URL(readEndpoint);
+            url.searchParams.set("user_email", lookup.user_email);
+            const isAiQuery = Boolean(lookup.session_id);
+            const identity = feedbackIdentity(lookup.query_id, lookup.feature_id, isAiQuery);
+            if (lookup.session_id)
+                url.searchParams.set("session_id", lookup.session_id);
+            else
+                url.searchParams.set("feature_id", "feature_id" in identity ? identity.feature_id
+                    : UUID4.test(lookup.feature_id) ? lookup.feature_id : stableFeatureUuid(`${lookup.feature_id}:${lookup.query_id}`));
+            const cacheKey = `${url.toString()}::${options.getAuthToken?.() ?? ""}`;
+            try {
+                let cached = readCache.get(cacheKey);
+                if (!cached || cached.expiresAt <= Date.now()) {
+                    const promise = fetcher(url.toString(), { headers: { accept: "application/json", ...authHeaders() } })
+                        .then(async (response) => {
+                        if (!response.ok)
+                            throw new Error(`Feedback lookup failed (${response.status})`);
+                        const body = asObject(await response.json());
+                        return Array.isArray(body.data) ? body.data : [];
+                    });
+                    cached = { expiresAt: Date.now() + READ_CACHE_MS, promise };
+                    readCache.set(cacheKey, cached);
+                    void promise.catch(() => { if (readCache.get(cacheKey)?.promise === promise)
+                        readCache.delete(cacheKey); });
+                }
+                const rows = await cached.promise;
+                const match = rows.find((raw) => {
+                    const item = asObject(raw);
+                    const metadata = asObject(item.form_metadata ?? item.metadata);
+                    const legacyMatch = !item.query_id && metadata.source_query_id === lookup.source_request_id;
+                    if (item.user_email !== lookup.user_email)
+                        return false;
+                    if (isAiQuery && lookup.session_id) {
+                        const sessionMatches = item.session_id === lookup.session_id || metadata.sessionId === lookup.session_id;
+                        const queryMatches = Boolean(lookup.query_id) && (item.query_id === lookup.query_id || metadata.source_query_id === lookup.query_id || legacyMatch);
+                        return sessionMatches && queryMatches;
+                    }
+                    const featureId = "feature_id" in identity ? identity.feature_id : lookup.feature_id;
+                    const featureMatches = item.feature_id === featureId || metadata.source_feature_id === lookup.feature_id;
+                    const requestMatches = !lookup.request_id || !item.request_id || item.request_id === lookup.request_id;
+                    return featureMatches && requestMatches;
+                });
+                return match ? writeSaved(options.baseUrl, remoteRecord(match, { ...lookup, is_ai_query: isAiQuery })) : null;
+            }
+            catch {
+                return readSaved(options.baseUrl, lookup);
+            }
+        },
+        async upsertFeedback(record) {
+            const form = record.feedback_form;
+            let previous = readSaved(options.baseUrl, { query_id: form.query_id, feature_id: form.feature_id, user_email: form.user_email });
+            const savedId = previous?.feedback_form.feedback_id;
+            const update = Boolean(savedId && UUID4.test(savedId));
+            const knownIds = asObject(previous?.feedback_form.metadata[SERVER_IDS_KEY]);
+            const knownPositive = Array.isArray(knownIds.positive) ? knownIds.positive : [];
+            const knownNegative = Array.isArray(knownIds.negative) ? knownIds.negative : [];
+            if (update && previous &&
+                (previous.positive_feedback.some((item) => !knownPositive.includes(item.positive_id)) ||
+                    previous.gaps.some((item) => !knownNegative.includes(item.negative_id)))) {
+                const hydrated = await fetchSavedById(previous.feedback_form);
+                if (!hydrated ||
+                    hydrated.positive_feedback.length < previous.positive_feedback.length ||
+                    hydrated.gaps.length < previous.gaps.length)
+                    throw new Error("Cannot safely update feedback without its saved answer IDs");
+                previous = writeSaved(options.baseUrl, hydrated);
+            }
+            const recordWithServerIds = previous?.feedback_form.metadata[SERVER_IDS_KEY]
+                ? {
+                    ...record,
+                    positive_feedback: record.positive_feedback.map((item, index) => ({
+                        ...item,
+                        positive_id: previous?.positive_feedback[index]?.positive_id ?? item.positive_id,
+                    })),
+                    gaps: record.gaps.map((gap, index) => ({
+                        ...gap,
+                        negative_id: previous?.gaps.find((item) => item.negative_id === gap.negative_id)?.negative_id ??
+                            (record.gaps.some((other, otherIndex) => otherIndex !== index &&
+                                other.negative_id === previous?.gaps[index]?.negative_id)
+                                ? undefined : previous?.gaps[index]?.negative_id) ?? gap.negative_id,
+                    })),
+                    feedback_form: {
+                        ...form,
+                        metadata: { ...form.metadata, [SERVER_IDS_KEY]: previous.feedback_form.metadata[SERVER_IDS_KEY] },
+                    },
+                }
+                : record;
+            const response = await fetcher(update ? `${endpoint}/${savedId}` : endpoint, {
+                method: update ? "PUT" : "POST",
+                headers: { accept: "application/json", "Content-Type": "application/json", ...authHeaders() },
+                body: JSON.stringify(requestPayload(recordWithServerIds, update)),
+            });
+            if (!response.ok)
+                throw new Error(`Feedback ${update ? "update" : "submission"} failed (${response.status})`);
+            const body = await response.json();
+            readCache.clear();
+            const serverId = feedbackId(body);
+            if (!update && !serverId)
+                throw new Error("Feedback saved, but the API did not return feedback_id for future updates");
+            // Keep the parent ID even if the nested IDs require a follow-up read.
+            // A retry must PUT this form, never create another feedback form.
+            writeSaved(options.baseUrl, {
+                ...recordWithServerIds,
+                feedback_form: {
+                    ...recordWithServerIds.feedback_form,
+                    feedback_id: serverId ?? savedId ?? form.feedback_id,
+                },
+            });
+            const returnedNestedIds = nestedServerIds(body);
+            const serverForm = { ...form, feedback_id: serverId ?? savedId ?? form.feedback_id };
+            const previousIds = asObject(previous?.feedback_form.metadata[SERVER_IDS_KEY]);
+            const knownPositiveIds = Array.isArray(previousIds.positive) ? previousIds.positive : [];
+            const knownNegativeIds = Array.isArray(previousIds.negative) ? previousIds.negative : [];
+            const needPositiveIds = recordWithServerIds.positive_feedback.some((item) => !knownPositiveIds.includes(item.positive_id)) &&
+                !returnedNestedIds.positive?.some(Boolean);
+            const needNegativeIds = recordWithServerIds.gaps.some((gap) => !knownNegativeIds.includes(gap.negative_id)) &&
+                !returnedNestedIds.negative?.some(Boolean);
+            const fetched = (needPositiveIds || needNegativeIds) ? await fetchSavedById(serverForm).catch(() => null) : null;
+            if ((needPositiveIds && !fetched?.positive_feedback.length && !asObject(previous?.feedback_form.metadata[SERVER_IDS_KEY]).positive) ||
+                (needNegativeIds && !fetched?.gaps.length && !asObject(previous?.feedback_form.metadata[SERVER_IDS_KEY]).negative)) {
+                throw new Error("Feedback saved, but its answer IDs could not be loaded safely; please retry after refreshing");
+            }
+            const nestedIds = {
+                positive: [...new Set([...knownPositiveIds, ...(fetched?.positive_feedback.map((item) => item.positive_id) ?? []), ...(returnedNestedIds.positive ?? [])].filter(Boolean))],
+                negative: [...new Set([...knownNegativeIds, ...(fetched?.gaps.map((item) => item.negative_id) ?? []), ...(returnedNestedIds.negative ?? [])].filter(Boolean))],
+            };
+            const resolvedPositive = recordWithServerIds.positive_feedback.map((item, index) => ({
+                ...item,
+                positive_id: knownPositiveIds.includes(item.positive_id) ? item.positive_id
+                    : returnedNestedIds.positive?.length === record.positive_feedback.length && returnedNestedIds.positive[index]
+                        ? returnedNestedIds.positive[index]
+                        : fetched?.positive_feedback.find((saved) => saved.description === item.description)?.positive_id ?? item.positive_id,
+            }));
+            const resolvedGaps = recordWithServerIds.gaps.map((gap, index) => ({
+                ...gap,
+                negative_id: knownNegativeIds.includes(gap.negative_id) ? gap.negative_id
+                    : returnedNestedIds.negative?.length === record.gaps.length && returnedNestedIds.negative[index]
+                        ? returnedNestedIds.negative[index]
+                        : fetched?.gaps.find((saved) => saved.description === gap.description && !knownNegativeIds.includes(saved.negative_id))?.negative_id ?? gap.negative_id,
+            }));
+            const saved = writeSaved(options.baseUrl, {
+                ...record,
+                positive_feedback: resolvedPositive,
+                gaps: resolvedGaps,
+                feedback_form: {
+                    ...form,
+                    feedback_id: serverId ?? savedId ?? form.feedback_id,
+                    metadata: { ...form.metadata, [SERVER_IDS_KEY]: nestedIds },
+                },
+            });
+            if (resolvedPositive.some((item) => !nestedIds.positive.includes(item.positive_id)) ||
+                resolvedGaps.some((item) => !nestedIds.negative.includes(item.negative_id)))
+                throw new Error("Feedback saved, but its answer IDs are not available yet; please retry shortly");
+            return saved;
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import "./feedback.css";
+export * from "./types";
+export * from "./tracking";
+export * from "./feedbackApi";
+export * from "./httpFeedbackApi";
+export * from "./feedbackUpload";
+export * from "./useFeedbackPersistence";
+export * from "./feedbackTheme";
+export * from "./featureAvailability";
+export * from "./FeedbackErrorBoundary";
+export * from "./useFeedbackFlow";
+export * from "./FeedbackPrompt";
+export * from "./FeedbackModal";
+export * from "./FeedbackExperience";
+export * from "./StarRating";

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./feedback.css");
+__exportStar(require("./types"), exports);
+__exportStar(require("./tracking"), exports);
+__exportStar(require("./feedbackApi"), exports);
+__exportStar(require("./httpFeedbackApi"), exports);
+__exportStar(require("./feedbackUpload"), exports);
+__exportStar(require("./useFeedbackPersistence"), exports);
+__exportStar(require("./feedbackTheme"), exports);
+__exportStar(require("./featureAvailability"), exports);
+__exportStar(require("./FeedbackErrorBoundary"), exports);
+__exportStar(require("./useFeedbackFlow"), exports);
+__exportStar(require("./FeedbackPrompt"), exports);
+__exportStar(require("./FeedbackModal"), exports);
+__exportStar(require("./FeedbackExperience"), exports);
+__exportStar(require("./StarRating"), exports);

package/dist/tracking.d.ts

@@ -0,0 +1,3 @@
+import type { FeedbackMetadata, FeedbackTrackingContext } from "./types";
+/** Merge mode tracking with legacy metadata. Explicit tracking fields take precedence. */
+export declare function createFeedbackMetadata(tracking?: FeedbackTrackingContext, metadata?: FeedbackMetadata): FeedbackMetadata | undefined;

package/dist/tracking.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFeedbackMetadata = createFeedbackMetadata;
+/** Merge mode tracking with legacy metadata. Explicit tracking fields take precedence. */
+function createFeedbackMetadata(tracking, metadata) {
+    if (!tracking && !metadata)
+        return undefined;
+    const result = Object.fromEntries(Object.entries({ ...metadata, ...tracking?.custom }).filter(([, value]) => value !== undefined));
+    if (tracking?.mode !== undefined)
+        result.mode = tracking.mode;
+    if (tracking?.modeId !== undefined)
+        result.modeId = tracking.modeId;
+    if (tracking?.owner !== undefined)
+        result.owner = tracking.owner;
+    if (tracking?.featureContext !== undefined)
+        result.featureContext = tracking.featureContext;
+    if (tracking?.userEmail !== undefined)
+        result.userEmail = tracking.userEmail;
+    if (tracking?.traceId !== undefined)
+        result.traceId = tracking.traceId;
+    return Object.keys(result).length ? result : undefined;
+}