@fluid-topics/public-api 1.0.49 → 1.0.50

package/build/cjs/index.js

@@ -0,0 +1,373 @@
+"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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FluidTopicsApi = exports.HttpError = void 0;
+require("cross-fetch/polyfill");
+const wnd = (typeof window === "undefined" ? globalThis : window);
+__exportStar(require("./types/ft-common/public"), exports);
+__exportStar(require("./types/ft-server/public"), exports);
+__exportStar(require("./roles/roles"), exports);
+__exportStar(require("./preferences/unauthenticated-preferences"), exports);
+function toBase64(s) {
+    return typeof Buffer !== "undefined" ? Buffer.from(s).toString("base64") : btoa(s);
+}
+class HttpError extends Error {
+    constructor(status, statusText, body) {
+        super(`${status} - ${statusText}: ${body}`);
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+    }
+}
+exports.HttpError = HttpError;
+function handleError(response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!response.ok) {
+            throw new HttpError(response.status, response.statusText, yield response.text());
+        }
+        return response;
+    });
+}
+function getBody(response) {
+    return response.headers.get("Content-Type") === "application/json" ? response.json() : response.text();
+}
+class FluidTopicsApi {
+    get defaultHeaders() {
+        return Object.assign(Object.assign(Object.assign({}, this.authorization), this.searchLabel), { "Ft-Calling-App": this.ftCallingApp });
+    }
+    constructor(tenantBaseUrl, integrationIdentifier, overrideIdentifierIfOnTenant) {
+        var _a, _b, _c, _d, _e, _f;
+        this.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}`,
+                        })
+                    }
+                })
+            },
+        };
+        //@ts-ignore
+        tenantBaseUrl = ((_f = (_c = (_a = tenantBaseUrl !== null && tenantBaseUrl !== void 0 ? tenantBaseUrl : wnd.__gwt_ft_moduleBase) !== null && _a !== void 0 ? _a : (_b = wnd.fluidtopicsclient) === null || _b === void 0 ? void 0 : _b.__moduleBase) !== null && _c !== void 0 ? _c : (_e = (_d = wnd.__gwt_activeModules) === null || _d === void 0 ? void 0 : _d.fluidtopicsclient) === null || _e === void 0 ? void 0 : _e.moduleBase) !== null && _f !== void 0 ? _f : "").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(/^\//, ""));
+    }
+    fetch(endpoint, init) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestInit = init;
+            return yield fetch(this.makeAbsolute(endpoint), Object.assign(Object.assign({}, (requestInit !== null && requestInit !== void 0 ? requestInit : {})), { headers: Object.assign(Object.assign({}, this.defaultHeaders), ((_a = requestInit === null || requestInit === void 0 ? void 0 : requestInit.headers) !== null && _a !== void 0 ? _a : {})) }));
+        });
+    }
+    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: Object.assign({}, (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();
+    }
+}
+exports.FluidTopicsApi = FluidTopicsApi;
+exports.default = FluidTopicsApi;

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addUnauthenticatedUserSearchPreferencesChangeHandler = exports.getUnauthenticatedUserSearchPreferences = exports.setUnauthenticatedUserSearchPreferences = void 0;
+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`;
+}
+function setUnauthenticatedUserSearchPreferences(tenantBaseUrl, input) {
+    var _a;
+    if (wnd.localStorage) {
+        let preferences = Object.assign(Object.assign({}, input), { metadata: normalizeMetadataPreferences((_a = input.metadata) !== null && _a !== void 0 ? _a : {}) });
+        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.");
+}
+exports.setUnauthenticatedUserSearchPreferences = setUnauthenticatedUserSearchPreferences;
+function getUnauthenticatedUserSearchPreferences(tenantBaseUrl) {
+    var _a;
+    if (wnd.localStorage) {
+        return JSON.parse((_a = wnd.localStorage.getItem(getStorageKey(tenantBaseUrl))) !== null && _a !== void 0 ? _a : "{}");
+    }
+    console.error("Cannot get unauthenticated preferences: local storage is unavailable.");
+}
+exports.getUnauthenticatedUserSearchPreferences = getUnauthenticatedUserSearchPreferences;
+function addUnauthenticatedUserSearchPreferencesChangeHandler(tenantBaseUrl, handler) {
+    if (wnd.localStorage) {
+        const key = getStorageKey(tenantBaseUrl);
+        const eventListener = (event) => {
+            var _a;
+            if (event.storageArea === wnd.localStorage && event.key === key) {
+                handler(JSON.parse((_a = event.newValue) !== null && _a !== void 0 ? _a : "{}"));
+            }
+        };
+        wnd.addEventListener("storage", eventListener);
+        return {
+            removeHandler: () => wnd.removeEventListener("storage", eventListener)
+        };
+    }
+    console.error("Cannot handle unauthenticated preferences: local storage is unavailable.");
+}
+exports.addUnauthenticatedUserSearchPreferencesChangeHandler = addUnauthenticatedUserSearchPreferencesChangeHandler;

package/build/cjs/roles/roles.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userHasRole = void 0;
+const public_1 = require("../types/ft-common/public");
+const rolesInheritance = {
+    [public_1.FtUserRole.PERSONAL_BOOK_SHARE_USER]: [public_1.FtUserRole.PERSONAL_BOOK_USER],
+    [public_1.FtUserRole.HTML_EXPORT_USER]: [public_1.FtUserRole.PERSONAL_BOOK_USER],
+    [public_1.FtUserRole.PDF_EXPORT_USER]: [public_1.FtUserRole.PERSONAL_BOOK_USER],
+    [public_1.FtUserRole.KHUB_ADMIN]: [public_1.FtUserRole.CONTENT_PUBLISHER],
+    [public_1.FtUserRole.ADMIN]: [public_1.FtUserRole.KHUB_ADMIN, public_1.FtUserRole.USERS_ADMIN, public_1.FtUserRole.PORTAL_ADMIN],
+    [public_1.FtUserRole.DEVELOPER]: [public_1.FtUserRole.BETA_USER, public_1.FtUserRole.DEBUG_USER],
+};
+function roleMatches(actual, expected) {
+    var _a;
+    return actual === expected || ((_a = rolesInheritance[actual]) !== null && _a !== void 0 ? _a : []).some((inherited) => roleMatches(inherited, expected));
+}
+function userHasRole(sessionOrProfileOrRoles, expectedRole) {
+    var _a;
+    if (sessionOrProfileOrRoles == null) {
+        return false;
+    }
+    const roles = Array.isArray(sessionOrProfileOrRoles)
+        ? sessionOrProfileOrRoles
+        : Array.isArray(sessionOrProfileOrRoles.roles)
+            ? sessionOrProfileOrRoles.roles
+            : Array.isArray((_a = sessionOrProfileOrRoles.profile) === null || _a === void 0 ? void 0 : _a.roles)
+                ? sessionOrProfileOrRoles.profile.roles
+                : [];
+    return roles.some(role => roleMatches(role, expectedRole));
+}
+exports.userHasRole = userHasRole;