@fluid-topics/public-api 1.0.49 → 1.0.51

package/build/cjs/types/ft-server/public.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFtPaginationConfiguration = exports.isFtPaginatedTocNode = exports.isFtPaginatedToc = exports.isFtPageConfiguration = exports.isFtMapAttachment = exports.isFtReaderFeedbackConfiguration = exports.isFtReaderConfiguration = void 0;
+const isObject = (o) => typeof o === "object" && o != null;
+const isBoolean = (o) => typeof o === "boolean";
+const isNumber = (o) => typeof o === "number";
+const isString = (o) => typeof o === "string";
+const isFtReaderConfiguration = (o) => {
+    return isObject(o)
+        && ((0, exports.isFtReaderFeedbackConfiguration)(o.feedback))
+        && (isNumber(o.loadAfterLastVisibleTopic))
+        && (isNumber(o.loadBeforeFirstVisibleTopic));
+};
+exports.isFtReaderConfiguration = isFtReaderConfiguration;
+const isFtReaderFeedbackConfiguration = (o) => {
+    return isObject(o)
+        && (isBoolean(o.mailsSentByFluidTopics))
+        && (isBoolean(o.mailsSentByFluidTopicsForUnauthenticatedUsers))
+        && ((Array.isArray(o.recipients)
+            && o.recipients.every((v) => isString(v))))
+        && ((Array.isArray(o.bodyMetadataIds)
+            && o.bodyMetadataIds.every((v) => isString(v))))
+        && ((Array.isArray(o.subjectMetadataIds)
+            && o.subjectMetadataIds.every((v) => isString(v))));
+};
+exports.isFtReaderFeedbackConfiguration = isFtReaderFeedbackConfiguration;
+const isFtMapAttachment = (o) => {
+    return isObject(o)
+        && (isString(o.file))
+        && (o.size == null || isNumber(o.size))
+        && (isBoolean(o.externalLink))
+        && (isString(o.name))
+        && (isString(o.id))
+        && (o.mimeType == null || isString(o.mimeType))
+        && (o.viewerUrl == null || isString(o.viewerUrl));
+};
+exports.isFtMapAttachment = isFtMapAttachment;
+const isFtPageConfiguration = (o) => {
+    return isObject(o)
+        && (o.parentsVisibility == null || (Array.isArray(o.parentsVisibility)
+            && o.parentsVisibility.every((v) => isBoolean(v))))
+        && (isBoolean(o.isVisible));
+};
+exports.isFtPageConfiguration = isFtPageConfiguration;
+const isFtPaginatedToc = (o) => {
+    return isObject(o)
+        && ((0, exports.isFtPaginationConfiguration)(o.configuration))
+        && ((Array.isArray(o.paginatedToc)
+            && o.paginatedToc.every((v) => (0, exports.isFtPaginatedTocNode)(v))));
+};
+exports.isFtPaginatedToc = isFtPaginatedToc;
+const isFtPaginatedTocNode = (o) => {
+    return isObject(o)
+        && (o.prettyUrl == null || isString(o.prettyUrl))
+        && (o.hasRating == null || isBoolean(o.hasRating))
+        && (o.pageToc == null || (Array.isArray(o.pageToc)))
+        && (o.tocId == null || isString(o.tocId))
+        && ((Array.isArray(o.children)
+            && o.children.every((v) => (0, exports.isFtPaginatedTocNode)(v))))
+        && (o.pageConfiguration == null || (0, exports.isFtPageConfiguration)(o.pageConfiguration))
+        && (o.contentId == null || isString(o.contentId))
+        && (o.title == null || isString(o.title));
+};
+exports.isFtPaginatedTocNode = isFtPaginatedTocNode;
+const isFtPaginationConfiguration = (o) => {
+    return isObject(o)
+        && (isBoolean(o.splitCurrentPageToc));
+};
+exports.isFtPaginationConfiguration = isFtPaginationConfiguration;

package/build/mjs/index.d.ts

@@ -0,0 +1,168 @@
+import "cross-fetch/polyfill";
+import { FtAuthenticatedSession, FtBookmark, FtCollectionDocument, FtMap, FtMapResource, FtMessageContext, FtMySearch, FtRatingSummary, FtRatingType, FtRatingTypeKeys, FtSearchLocales, FtSearchRequest, FtSearchResults, FtSession, FtSuggestRequest, FtSuggestResults, FtTocNode, FtTopic, FtTopicContentTarget, FtTopicContentTargetKeys, FtUiLocale, FtUnstructuredDocument } from "./types/ft-common/public";
+import { FtMapAttachment, FtPaginatedToc, FtReaderConfiguration } from "./types/ft-server/public";
+export * from "./types/ft-common/public";
+export * from "./types/ft-server/public";
+export * from "./roles/roles";
+export * from "./preferences/unauthenticated-preferences";
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: string;
+    constructor(status: number, statusText: string, body: string);
+}
+export declare class FluidTopicsApi {
+    readonly tenantBaseUrl: string;
+    private readonly ftCallingApp;
+    private authorization?;
+    private searchLabel?;
+    readonly endpoints: {
+        authentication: {
+            login: string;
+            logout: string;
+            currentSession: string;
+        };
+        khub: {
+            maps: {
+                mapId: (mapId: string) => {
+                    info: string;
+                    toc: string;
+                    pages: string;
+                    feedback: string;
+                    rating: string;
+                    attachments: {
+                        list: string;
+                        attachmentId: (attachmentId: string) => {
+                            content: string;
+                        };
+                    };
+                    resources: {
+                        list: string;
+                        resourceId: (resourceId: string) => {
+                            content: string;
+                        };
+                    };
+                    topics: {
+                        contentId: (contentId: string) => {
+                            info: string;
+                            content: string;
+                        };
+                        tocId: (tocId: string) => {
+                            feedback: string;
+                            rating: string;
+                        };
+                    };
+                };
+            };
+            documents: {
+                documentId: (documentId: string) => {
+                    info: string;
+                    content: string;
+                    text: string;
+                    feedback: string;
+                    rating: string;
+                };
+            };
+            suggest: string;
+            clusteredSearch: string;
+            locales: string;
+        };
+        users: {
+            userId: (userId: string) => {
+                collections: {
+                    collectionId: (collectionId: string) => {
+                        documents: string;
+                    };
+                };
+                searches: {
+                    list: string;
+                };
+                bookmarks: {
+                    list: string;
+                };
+            };
+        };
+        stylesheets: {
+            fonts: string;
+            theme: string;
+            content: {
+                title: string;
+                topic: string;
+            };
+        };
+        configuration: {
+            reader: string;
+        };
+        locales: {
+            ui: string;
+        };
+        messages: {
+            locale: (locale: string) => {
+                fluidTopics: {
+                    contextName: (contextName: string) => {
+                        endpoint: string;
+                    };
+                };
+                custom: {
+                    contextName: (contextName: string) => {
+                        endpoint: string;
+                    };
+                };
+            };
+        };
+    };
+    private get defaultHeaders();
+    constructor(tenantBaseUrl: string, integrationIdentifier: string, overrideIdentifierIfOnTenant?: boolean);
+    setApiKey(apiKey: string): void;
+    setCredentials(login: string, password: string): void;
+    clearAuthentication(): void;
+    setSearchLabel(searchLabel: string): void;
+    clearSearchLabel(): void;
+    login(login: string, password: string): Promise<FtAuthenticatedSession>;
+    logout(): Promise<void>;
+    getCurrentSession(): Promise<FtSession>;
+    getReaderConfiguration(): Promise<FtReaderConfiguration>;
+    getMap(mapId: string, v?: string): Promise<FtMap>;
+    getTableOfContent(mapId: string, v?: string): Promise<Array<FtTocNode>>;
+    getPages(mapId: string, v?: string): Promise<FtPaginatedToc>;
+    getTopic(mapId: string, topicContentId: string, v?: string): Promise<FtTopic>;
+    getTopicHTMLContent(mapId: string, topicContentId: string, target?: FtTopicContentTarget | FtTopicContentTargetKeys, v?: string): Promise<string>;
+    getMapAttachments(mapId: string, v?: string): Promise<Array<FtMapAttachment>>;
+    getMapAttachmentContent(mapId: string, attachmentId: string, v?: string): Promise<ArrayBuffer>;
+    getMapResources(mapId: string, v?: string): Promise<Array<FtMapResource>>;
+    getMapResourceContent(mapId: string, resourceId: string, v?: string): Promise<ArrayBuffer>;
+    getUnstructuredDocument(documentId: string, v?: string): Promise<FtUnstructuredDocument>;
+    getUnstructuredDocumentContent(documentId: string, v?: string): Promise<ArrayBuffer>;
+    getUnstructuredDocumentTextContent(documentId: string, v?: string): Promise<string>;
+    getCollectionDocuments(userId: string, collectionId: string): Promise<Array<FtCollectionDocument>>;
+    getSuggestions(request: FtSuggestRequest): Promise<FtSuggestResults>;
+    search(request: FtSearchRequest): Promise<FtSearchResults>;
+    getAvailableSearchLocales(): Promise<FtSearchLocales>;
+    getAvailableUiLocales(): Promise<Array<FtUiLocale>>;
+    getMapRating(mapId: string): Promise<FtRatingSummary>;
+    rateMap(mapId: string, type: FtRatingType | FtRatingTypeKeys, value: number): Promise<void>;
+    unrateMap(mapId: string): Promise<void>;
+    sendMapFeedback(mapId: string, message: string, from?: string): Promise<void>;
+    rateTopic(mapId: string, tocId: string, type: FtRatingType | FtRatingTypeKeys, value: number): Promise<void>;
+    unrateTopic(mapId: string, tocId: string): Promise<void>;
+    sendTopicFeedback(mapId: string, tocId: string, message: string, from?: string): Promise<void>;
+    getDocumentRating(docId: string): Promise<FtRatingSummary>;
+    rateDocument(docId: string, type: FtRatingType | FtRatingTypeKeys, value: number): Promise<void>;
+    unrateDocument(docId: string): Promise<void>;
+    sendDocumentFeedback(docId: string, message: string, from?: string): Promise<void>;
+    getFluidTopicsMessageContext(locale: string, name: string): Promise<FtMessageContext>;
+    getCustomMessageContext(locale: string, name: string): Promise<FtMessageContext>;
+    listMySearches(userId: string): Promise<FtMySearch[]>;
+    listMyBookmarks(userId: string): Promise<FtBookmark[]>;
+    get<T>(endpoint: string, v?: string): Promise<T>;
+    post<T>(endpoint: string, data?: any): Promise<T>;
+    put<T>(endpoint: string, data?: any): Promise<T>;
+    delete<T>(endpoint: string): Promise<T>;
+    makeAbsolute(endpoint: string): string;
+    fetch<FetchRequestInit, FetchResponse>(endpoint: string, init?: FetchRequestInit): Promise<FetchResponse>;
+    upload<T>(method: string, endpoint: string, body: any, onProgress?: (e: any) => void): Promise<T>;
+    private makeRequest;
+    private fetchRawData;
+    withVersion(endpoint: string, v: string | undefined): string;
+}
+export default FluidTopicsApi;

package/build/mjs/index.js

@@ -0,0 +1,358 @@
+import "cross-fetch/polyfill";
+const wnd = (typeof window === "undefined" ? globalThis : window);
+export * from "./types/ft-common/public";
+export * from "./types/ft-server/public";
+export * from "./roles/roles";
+export * from "./preferences/unauthenticated-preferences";
+function toBase64(s) {
+    return typeof Buffer !== "undefined" ? Buffer.from(s).toString("base64") : btoa(s);
+}
+export class HttpError extends Error {
+    status;
+    statusText;
+    body;
+    constructor(status, statusText, body) {
+        super(`${status} - ${statusText}: ${body}`);
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+    }
+}
+async function handleError(response) {
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, await response.text());
+    }
+    return response;
+}
+function getBody(response) {
+    return response.headers.get("Content-Type") === "application/json" ? response.json() : response.text();
+}
+export class FluidTopicsApi {
+    tenantBaseUrl;
+    ftCallingApp;
+    authorization;
+    searchLabel;
+    endpoints = {
+        authentication: {
+            login: `api/authentication/login`,
+            logout: `api/authentication/logout`,
+            currentSession: `api/authentication/current-session`,
+        },
+        khub: {
+            maps: {
+                mapId: (mapId) => ({
+                    info: `api/khub/maps/${mapId}`,
+                    toc: `api/khub/maps/${mapId}/toc`,
+                    pages: `api/khub/maps/${mapId}/pages`,
+                    feedback: `api/khub/maps/${mapId}/feedback`,
+                    rating: `api/khub/maps/${mapId}/rating`,
+                    attachments: {
+                        list: `api/khub/maps/${mapId}/attachments`,
+                        attachmentId: (attachmentId) => ({
+                            content: `api/khub/maps/${mapId}/attachments/${attachmentId}/content`,
+                        })
+                    },
+                    resources: {
+                        list: `api/khub/maps/${mapId}/resources`,
+                        resourceId: (resourceId) => ({
+                            content: `api/khub/maps/${mapId}/resources/${resourceId}/content`,
+                        })
+                    },
+                    topics: {
+                        contentId: (contentId) => ({
+                            info: `api/khub/maps/${mapId}/topics/${contentId}`,
+                            content: `api/khub/maps/${mapId}/topics/${contentId}/content`,
+                        }),
+                        tocId: (tocId) => ({
+                            feedback: `api/khub/maps/${mapId}/topics/${tocId}/feedback`,
+                            rating: `api/khub/maps/${mapId}/topics/${tocId}/rating`,
+                        })
+                    },
+                })
+            },
+            documents: {
+                documentId: (documentId) => ({
+                    info: `api/khub/documents/${documentId}`,
+                    content: `api/khub/documents/${documentId}/content`,
+                    text: `api/khub/documents/${documentId}/content/text`,
+                    feedback: `api/khub/documents/${documentId}/feedback`,
+                    rating: `api/khub/documents/${documentId}/rating`,
+                })
+            },
+            suggest: `api/khub/suggest`,
+            clusteredSearch: `api/khub/clustered-search`,
+            locales: `api/khub/locales`,
+        },
+        users: {
+            userId: (userId) => ({
+                collections: {
+                    collectionId: (collectionId) => ({
+                        documents: `api/users/${userId}/collections/${collectionId}/documents`,
+                    })
+                },
+                searches: {
+                    list: `api/users/${userId}/searches`
+                },
+                bookmarks: {
+                    list: `api/users/${userId}/bookmarks`
+                }
+            }),
+        },
+        stylesheets: {
+            fonts: `api/stylesheets/fonts.css`,
+            theme: `api/stylesheets/theme.css`,
+            content: {
+                title: `api/stylesheets/content/title.css`,
+                topic: `api/stylesheets/content/topic.css`,
+            },
+        },
+        configuration: {
+            reader: `api/configuration/reader`
+        },
+        locales: {
+            ui: `api/locales/ui`
+        },
+        messages: {
+            locale: (locale) => ({
+                fluidTopics: {
+                    contextName: (contextName) => ({
+                        endpoint: `api/messages/${locale}/fluid-topics/${contextName}`,
+                    })
+                },
+                custom: {
+                    contextName: (contextName) => ({
+                        endpoint: `api/messages/${locale}/custom/${contextName}`,
+                    })
+                }
+            })
+        },
+    };
+    get defaultHeaders() {
+        return {
+            ...this.authorization,
+            ...this.searchLabel,
+            "Ft-Calling-App": this.ftCallingApp
+        };
+    }
+    constructor(tenantBaseUrl, integrationIdentifier, overrideIdentifierIfOnTenant) {
+        //@ts-ignore
+        tenantBaseUrl = (tenantBaseUrl ?? wnd.__gwt_ft_moduleBase ?? wnd.fluidtopicsclient?.__moduleBase ?? wnd.__gwt_activeModules?.fluidtopicsclient?.moduleBase ?? "").trim();
+        this.tenantBaseUrl = tenantBaseUrl.endsWith("/") ? tenantBaseUrl : tenantBaseUrl + "/";
+        if (overrideIdentifierIfOnTenant && typeof wnd.location !== "undefined" && wnd.location.href.startsWith(this.tenantBaseUrl)) {
+            this.ftCallingApp = integrationIdentifier;
+        }
+        else {
+            this.ftCallingApp = `ft-public-api/${integrationIdentifier}`;
+        }
+    }
+    setApiKey(apiKey) {
+        this.authorization = { "Authorization": "Bearer " + apiKey };
+    }
+    setCredentials(login, password) {
+        this.authorization = { "Authorization": "Basic " + toBase64(`${login}:${password}`) };
+    }
+    clearAuthentication() {
+        this.authorization = undefined;
+    }
+    setSearchLabel(searchLabel) {
+        this.searchLabel = { "FT-search-label": searchLabel };
+    }
+    clearSearchLabel() {
+        this.searchLabel = undefined;
+    }
+    login(login, password) {
+        let credentials = {
+            login: login,
+            password: password,
+            rememberMe: true
+        };
+        return this.post(this.endpoints.authentication.login, credentials)
+            .then(result => {
+            this.setCredentials(login, password);
+            return result;
+        });
+    }
+    logout() {
+        return this.post(this.endpoints.authentication.logout)
+            .then(() => this.clearAuthentication());
+    }
+    getCurrentSession() {
+        return this.get(this.endpoints.authentication.currentSession);
+    }
+    getReaderConfiguration() {
+        return this.get(this.endpoints.configuration.reader);
+    }
+    getMap(mapId, v) {
+        return this.get(this.endpoints.khub.maps.mapId(mapId).info, v);
+    }
+    getTableOfContent(mapId, v) {
+        return this.get(this.endpoints.khub.maps.mapId(mapId).toc, v);
+    }
+    getPages(mapId, v) {
+        return this.get(this.endpoints.khub.maps.mapId(mapId).pages, v);
+    }
+    getTopic(mapId, topicContentId, v) {
+        return this.get(this.endpoints.khub.maps.mapId(mapId).topics.contentId(topicContentId).info, v);
+    }
+    getTopicHTMLContent(mapId, topicContentId, target, v) {
+        return this.get(this.endpoints.khub.maps.mapId(mapId).topics.contentId(topicContentId).content + (target ? "?target=" + target : ""), v);
+    }
+    getMapAttachments(mapId, v) {
+        return this.get(this.endpoints.khub.maps.mapId(mapId).attachments.list, v);
+    }
+    getMapAttachmentContent(mapId, attachmentId, v) {
+        return this.fetchRawData(this.endpoints.khub.maps.mapId(mapId).attachments.attachmentId(attachmentId).content, v);
+    }
+    getMapResources(mapId, v) {
+        return this.get(this.endpoints.khub.maps.mapId(mapId).resources.list, v);
+    }
+    getMapResourceContent(mapId, resourceId, v) {
+        return this.fetchRawData(this.endpoints.khub.maps.mapId(mapId).resources.resourceId(resourceId).content, v);
+    }
+    getUnstructuredDocument(documentId, v) {
+        return this.get(this.endpoints.khub.documents.documentId(documentId).info, v);
+    }
+    getUnstructuredDocumentContent(documentId, v) {
+        return this.fetchRawData(this.endpoints.khub.documents.documentId(documentId).content, v);
+    }
+    getUnstructuredDocumentTextContent(documentId, v) {
+        return this.get(this.endpoints.khub.documents.documentId(documentId).text, v);
+    }
+    getCollectionDocuments(userId, collectionId) {
+        return this.get(this.endpoints.users.userId(userId).collections.collectionId(collectionId).documents);
+    }
+    getSuggestions(request) {
+        return this.post(this.endpoints.khub.suggest, request);
+    }
+    search(request) {
+        return this.post(this.endpoints.khub.clusteredSearch, request);
+    }
+    getAvailableSearchLocales() {
+        return this.get(this.endpoints.khub.locales);
+    }
+    getAvailableUiLocales() {
+        return this.get(this.endpoints.khub.locales);
+    }
+    getMapRating(mapId) {
+        return this.get(this.endpoints.khub.maps.mapId(mapId).rating);
+    }
+    rateMap(mapId, type, value) {
+        return this.post(this.endpoints.khub.maps.mapId(mapId).rating, { type, value });
+    }
+    unrateMap(mapId) {
+        return this.delete(this.endpoints.khub.maps.mapId(mapId).rating);
+    }
+    sendMapFeedback(mapId, message, from) {
+        return this.post(this.endpoints.khub.maps.mapId(mapId).feedback, { message, from });
+    }
+    rateTopic(mapId, tocId, type, value) {
+        return this.post(this.endpoints.khub.maps.mapId(mapId).topics.tocId(tocId).rating, {
+            type, value
+        });
+    }
+    unrateTopic(mapId, tocId) {
+        return this.delete(this.endpoints.khub.maps.mapId(mapId).topics.tocId(tocId).rating);
+    }
+    sendTopicFeedback(mapId, tocId, message, from) {
+        return this.post(this.endpoints.khub.maps.mapId(mapId).topics.tocId(tocId).feedback, { message, from });
+    }
+    getDocumentRating(docId) {
+        return this.get(this.endpoints.khub.documents.documentId(docId).rating);
+    }
+    rateDocument(docId, type, value) {
+        return this.post(this.endpoints.khub.documents.documentId(docId).rating, { type, value });
+    }
+    unrateDocument(docId) {
+        return this.delete(this.endpoints.khub.documents.documentId(docId).rating);
+    }
+    sendDocumentFeedback(docId, message, from) {
+        return this.post(this.endpoints.khub.documents.documentId(docId).feedback, { message, from });
+    }
+    getFluidTopicsMessageContext(locale, name) {
+        return this.get(this.endpoints.messages.locale(locale).fluidTopics.contextName(name).endpoint);
+    }
+    getCustomMessageContext(locale, name) {
+        return this.get(this.endpoints.messages.locale(locale).custom.contextName(name).endpoint);
+    }
+    listMySearches(userId) {
+        return this.get(this.endpoints.users.userId(userId).searches.list);
+    }
+    listMyBookmarks(userId) {
+        return this.get(this.endpoints.users.userId(userId).bookmarks.list);
+    }
+    get(endpoint, v) {
+        return this.makeRequest("GET", this.withVersion(endpoint, v));
+    }
+    post(endpoint, data) {
+        return this.makeRequest("POST", endpoint, data);
+    }
+    put(endpoint, data) {
+        return this.makeRequest("PUT", endpoint, data);
+    }
+    delete(endpoint) {
+        return this.makeRequest("DELETE", endpoint);
+    }
+    makeAbsolute(endpoint) {
+        return endpoint.startsWith(this.tenantBaseUrl) ? endpoint : (this.tenantBaseUrl + endpoint.replace(/^\//, ""));
+    }
+    async fetch(endpoint, init) {
+        const requestInit = init;
+        return await fetch(this.makeAbsolute(endpoint), {
+            ...(requestInit ?? {}),
+            headers: {
+                ...this.defaultHeaders,
+                ...(requestInit?.headers ?? {})
+            }
+        });
+    }
+    upload(method, endpoint, body, onProgress = () => undefined) {
+        if (typeof XMLHttpRequest !== "undefined") {
+            return new Promise((resolve, reject) => {
+                let xhr = new XMLHttpRequest();
+                xhr.onload = () => {
+                    if (xhr.status >= 200 && xhr.status < 300) {
+                        let data = xhr.getResponseHeader("Content-Type") === "application/json" ? JSON.parse(xhr.responseText) : xhr.responseText;
+                        resolve(data);
+                    }
+                    else {
+                        reject(new HttpError(xhr.status, xhr.statusText, xhr.responseText));
+                    }
+                };
+                xhr.upload.onprogress = (e) => onProgress(e);
+                xhr.open(method, this.makeAbsolute(endpoint), true);
+                xhr.send(body);
+            });
+        }
+        else {
+            return this.fetch(endpoint, { method, body }).then(handleError).then(getBody);
+        }
+    }
+    makeRequest(method, endpoint, data) {
+        return this.fetch(endpoint, {
+            method: method,
+            headers: {
+                ...(data != null ? { "Content-Type": "application/json" } : {})
+            },
+            body: data != null ? JSON.stringify(data) : undefined,
+            credentials: this.authorization == null ? "include" : undefined
+        })
+            .then(handleError)
+            .then(getBody);
+    }
+    fetchRawData(endpoint, v) {
+        return fetch(this.withVersion(endpoint, v), {
+            headers: this.defaultHeaders,
+            credentials: this.authorization == null ? "include" : undefined
+        })
+            .then(handleError)
+            .then(response => response.arrayBuffer());
+    }
+    withVersion(endpoint, v) {
+        let url = new URL(this.makeAbsolute(endpoint));
+        if (v) {
+            url.searchParams.append("v", v);
+        }
+        return url.toString();
+    }
+}
+export default FluidTopicsApi;

package/build/mjs/preferences/unauthenticated-preferences.d.ts

@@ -0,0 +1,9 @@
+import { FtMetadataPreferenceConfiguration, FtSearchPreferencesConfiguration } from "../types/ft-common/public";
+export declare function setUnauthenticatedUserSearchPreferences(tenantBaseUrl: string, input: FtSearchPreferencesConfiguration): {
+    metadata: Record<string, FtMetadataPreferenceConfiguration>;
+};
+export declare function getUnauthenticatedUserSearchPreferences(tenantBaseUrl: string): FtSearchPreferencesConfiguration;
+export type HandlerRegistration = {
+    removeHandler: () => void;
+};
+export declare function addUnauthenticatedUserSearchPreferencesChangeHandler(tenantBaseUrl: string, handler: (newValue: FtSearchPreferencesConfiguration) => void): HandlerRegistration;

package/build/mjs/preferences/unauthenticated-preferences.js

@@ -0,0 +1,61 @@
+const wnd = (typeof window === "undefined" ? globalThis : window);
+function normalizeMetadataPreferences(metadata) {
+    let normalized = {};
+    for (let key in metadata) {
+        let values = metadata[key];
+        if (typeof values !== "object" || Array.isArray(values)) {
+            values = { prior: values };
+        }
+        for (let property of ["prior", "filter"]) {
+            values[property] = Array.isArray(values[property]) ? values[property] : [values[property]];
+            values[property] = values[property]
+                .map(v => v != null ? "" + v : "")
+                .filter(v => v !== "");
+        }
+        normalized[key] = values;
+    }
+    return normalized;
+}
+function getStorageKey(tenantBaseUrl) {
+    return `${tenantBaseUrl}-FluidTopicsUnauthenticatedUserSearchPreferences`;
+}
+export function setUnauthenticatedUserSearchPreferences(tenantBaseUrl, input) {
+    if (wnd.localStorage) {
+        let preferences = {
+            ...input,
+            metadata: normalizeMetadataPreferences(input.metadata ?? {})
+        };
+        const key = getStorageKey(tenantBaseUrl);
+        const newValue = JSON.stringify(preferences);
+        wnd.localStorage.setItem(key, newValue);
+        wnd.dispatchEvent(new StorageEvent("storage", {
+            key,
+            newValue,
+            storageArea: wnd.localStorage,
+            url: wnd.location.href
+        }));
+        return preferences;
+    }
+    console.error("Cannot set unauthenticated preferences: local storage is unavailable.");
+}
+export function getUnauthenticatedUserSearchPreferences(tenantBaseUrl) {
+    if (wnd.localStorage) {
+        return JSON.parse(wnd.localStorage.getItem(getStorageKey(tenantBaseUrl)) ?? "{}");
+    }
+    console.error("Cannot get unauthenticated preferences: local storage is unavailable.");
+}
+export function addUnauthenticatedUserSearchPreferencesChangeHandler(tenantBaseUrl, handler) {
+    if (wnd.localStorage) {
+        const key = getStorageKey(tenantBaseUrl);
+        const eventListener = (event) => {
+            if (event.storageArea === wnd.localStorage && event.key === key) {
+                handler(JSON.parse(event.newValue ?? "{}"));
+            }
+        };
+        wnd.addEventListener("storage", eventListener);
+        return {
+            removeHandler: () => wnd.removeEventListener("storage", eventListener)
+        };
+    }
+    console.error("Cannot handle unauthenticated preferences: local storage is unavailable.");
+}

package/build/mjs/roles/roles.d.ts

@@ -0,0 +1,2 @@
+import { FtSession, FtUserProfile, FtUserRole, FtUserRoleKeys } from "../types/ft-common/public";
+export declare function userHasRole(sessionOrProfileOrRoles: FtSession | FtUserProfile | Array<FtUserRole | FtUserRoleKeys> | undefined, expectedRole: FtUserRole | FtUserRoleKeys): boolean;