@c-rex/services 0.1.16 → 0.1.18

package/dist/index.js

@@ -1,682 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  DirectoryNodesService: () => DirectoryNodesService,
-  DocumentTypesService: () => DocumentTypesService,
-  InformationUnitsService: () => InformationUnitsService,
-  LanguageService: () => LanguageService,
-  RenditionsService: () => RenditionsService,
-  TopicsService: () => TopicsService
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/baseService.ts
-var import_requests = require("@c-rex/core/requests");
-
-// ../constants/src/index.ts
-var CONTENT_LANG_KEY = "CONTENT_LANG_KEY";
-var UI_LANG_KEY = "UI_LANG_KEY";
-var FLAGS_BY_LANG = {
-  "en": "US",
-  "de": "DE"
-};
-var EN_LANG = "en";
-var TOPIC = "TOPIC";
-var DOCUMENT = "DOCUMENT";
-var PACKAGE = "PACKAGE";
-var FRAGMENT = "FRAGMENT";
-var RESULT_TYPES = {
-  TOPIC,
-  DOCUMENT,
-  PACKAGE,
-  FRAGMENT
-};
-var DEFAULT_COOKIE_LIMIT = 30 * 24 * 60 * 60 * 1e3;
-var WILD_CARD_OPTIONS = {
-  BOTH: "BOTH",
-  END: "END",
-  START: "START",
-  NONE: "NONE"
-};
-var OPERATOR_OPTIONS = {
-  AND: "AND",
-  OR: "OR"
-};
-
-// ../utils/src/utils.ts
-var getCountryCodeByLang = (lang) => {
-  const mappedKeys = Object.keys(FLAGS_BY_LANG);
-  if (!mappedKeys.includes(lang)) {
-    return lang;
-  }
-  const country = FLAGS_BY_LANG[lang];
-  return country;
-};
-var formatDateToLocale = (date, locale) => {
-  if (typeof date !== "string" || !date) {
-    return date;
-  }
-  const dateAux = new Date(date);
-  return new Intl.DateTimeFormat(locale, {
-    day: "2-digit",
-    month: "long",
-    year: "numeric"
-  }).format(dateAux);
-};
-
-// ../utils/src/classMerge.ts
-var import_clsx = require("clsx");
-var import_tailwind_merge = require("tailwind-merge");
-
-// ../utils/src/params.ts
-var createParams = (fieldsList, key = "Fields") => {
-  if (!fieldsList || fieldsList.length === 0) {
-    return [];
-  }
-  return fieldsList.map((item) => ({
-    key,
-    value: item
-  }));
-};
-var generateQueryParams = (params) => {
-  const queryParams = params.map((param) => `${encodeURIComponent(param.key)}=${encodeURIComponent(param.value)}`).join("&");
-  return queryParams;
-};
-
-// ../utils/src/renditions.ts
-var getFileRenditions = ({ renditions }) => {
-  if (renditions == void 0 || renditions.length == 0) {
-    return {};
-  }
-  const filteredRenditions = renditions.filter(
-    (item) => item.format != "application/xhtml+xml" && item.format != "application/json" && item.format != "application/llm+xml"
-  );
-  if (filteredRenditions.length == 0 || filteredRenditions[0] == void 0) {
-    return {};
-  }
-  const result = {};
-  filteredRenditions.forEach((item) => {
-    const key = item.format;
-    if (result[key] == void 0) {
-      result[key] = {
-        view: "",
-        download: ""
-      };
-    }
-    result[key].download = item.links.filter((link) => link.rel == "download")[0]?.href;
-    result[key].view = item.links.filter((link) => link.rel == "view")[0]?.href;
-  });
-  return result;
-};
-
-// src/baseService.ts
-var BaseService = class {
-  api;
-  endpoint;
-  /**
-   * Creates a new instance of BaseService.
-   * 
-   * @param endpoint - The API endpoint URL for this service
-   */
-  constructor(endpoint) {
-    this.api = new import_requests.CrexApi();
-    this.endpoint = endpoint;
-  }
-  /**
-   * Makes an API request to the specified endpoint.
-   * 
-   * @param options - Request configuration options
-   * @param options.path - Optional path to append to the endpoint
-   * @param options.params - Optional query parameters to include in the request
-   * @param options.method - HTTP method to use (defaults to 'get')
-   * @param options.transformer - Optional function to transform the response data
-   * @returns The response data, optionally transformed
-   * @throws Error if the API request fails
-   */
-  async request({
-    path = "",
-    method = "get",
-    params = [],
-    headers = {},
-    transformer = (response) => response
-  }) {
-    let url = `${this.endpoint}${path}`;
-    const queryParams = generateQueryParams(params);
-    if (queryParams.length > 0) {
-      url += `?${queryParams}`;
-    }
-    const response = await this.api.execute({
-      url,
-      method,
-      headers
-    });
-    return await transformer(response);
-  }
-};
-
-// src/renditions.ts
-var RenditionsService = class extends BaseService {
-  constructor() {
-    super("Renditions/");
-  }
-  /**
-   * Retrieves the HTML rendition from a list of renditions.
-   * Filters for renditions with format 'application/xhtml+xml' and rel 'view'.
-   * 
-   * @param renditions - Array of rendition objects to process
-   * @returns A promise that resolves to the HTML content as a string, or empty string if no suitable rendition is found
-   * @throws Error if the API request fails
-   */
-  async getHTMLRendition({ renditions }) {
-    const filteredRenditions = renditions.filter(
-      (item2) => item2.format == "application/xhtml+xml"
-    );
-    if (filteredRenditions.length == 0 || filteredRenditions[0] == void 0) return "";
-    const item = filteredRenditions[0];
-    const filteredLinks = item.links.filter((item2) => item2.rel == "view");
-    if (filteredLinks.length == 0 || filteredLinks[0] == void 0) return "";
-    const url = filteredLinks[0].href;
-    const response = await this.api.execute({
-      url,
-      method: "get",
-      headers: {
-        Accept: "application/xhtml+xml"
-      }
-    });
-    return response;
-  }
-};
-
-// src/directoryNodes.ts
-var DirectoryNodesService = class extends BaseService {
-  constructor() {
-    super("DirectoryNodes/");
-  }
-  /**
-   * Retrieves a specific directory node by its ID.
-   * 
-   * @param id - The unique identifier of the directory node
-   * @returns A promise that resolves to the directory node data
-   * @throws Error if the API request fails
-   */
-  async getItem(id) {
-    return await this.request({
-      path: id
-    });
-  }
-  /**
-   * Retrieves a list of directory nodes based on specified filters.
-   * 
-   * @param options - Options for filtering the directory nodes list
-   * @param options.filters - Optional array of filter strings to apply
-   * @returns A promise that resolves to the directory nodes response
-   * @throws Error if the API request fails
-   */
-  async getList({
-    filters = []
-  }) {
-    const remainFilters = createParams(filters, "Filter");
-    return await this.request({
-      params: {
-        ...remainFilters
-      }
-    });
-  }
-};
-
-// src/transforms/documentTypes.ts
-var import_sdk = require("@c-rex/core/sdk");
-var import_headers = require("next/headers");
-var transformDocumentTypes = async (data) => {
-  const labels = [];
-  const sdk = new import_sdk.CrexSDK();
-  const config = sdk.getClientConfig();
-  const contentLanguage = (0, import_headers.cookies)().get(CONTENT_LANG_KEY)?.value || config.languageSwitcher.default;
-  const language = contentLanguage.split("-")[0];
-  data.items.forEach((documentItem) => {
-    const label = documentItem.labels.find((item) => item.language.toLowerCase() === language.toLowerCase());
-    labels.push({
-      shortId: documentItem.shortId,
-      label: label ? label.value : ""
-    });
-  });
-  return labels;
-};
-
-// src/documentTypes.ts
-var DocumentTypesService = class extends BaseService {
-  constructor() {
-    super("DocumentTypes/");
-  }
-  /**
-   * Retrieves document type labels for the specified fields.
-   * 
-   * @returns A promise that resolves to an array of label strings
-   * @throws Error if the API request fails
-   */
-  async getLabels() {
-    return await this.request({
-      params: [{
-        key: "sparqlWhere",
-        value: "?iu iirds:is-applicable-for-document-type ?s . ?iu iirds:has-topic-type <https://www.c-rex.net/iirds/td#Blogpost>"
-      }],
-      transformer: transformDocumentTypes
-    });
-  }
-};
-
-// src/transforms/information.ts
-var import_headers2 = require("next/headers");
-var import_logger = require("@c-rex/core/logger");
-var import_sdk2 = require("@c-rex/core/sdk");
-var transformInformationUnits = async (data) => {
-  const logger = new import_logger.CrexLogger();
-  const sdk = new import_sdk2.CrexSDK();
-  const frontEndConfig = sdk.getClientConfig();
-  const backEndConfig = sdk.getServerConfig();
-  const filteredTags = {};
-  const items = data.items.map((item) => {
-    const type = item.class.labels.filter((item2) => item2.language === EN_LANG)[0].value.toUpperCase();
-    const files = getFileRenditions({ renditions: item?.renditions });
-    let link = `/topics/${item.shortId}`;
-    if (frontEndConfig.results.articlePageLayout == "BLOG") {
-      link = `/blog/${item.shortId}`;
-    } else if (type == RESULT_TYPES.DOCUMENT) {
-      link = `/documents/${item.shortId}`;
-    }
-    let title = "NO TITLE";
-    if (item.titles) {
-      title = item.titles[0].value;
-    } else if (item.labels) {
-      title = item.labels[0].value;
-    }
-    let language = "NO LANGUAGE";
-    if (item.languages.length > 0) {
-      language = item.languages[0];
-    }
-    let versionOf = [];
-    if (item?.versionOf && item.versionOf?.labels) {
-      versionOf = item.versionOf.labels.map((item2) => item2.language).filter((value) => value !== void 0);
-    }
-    return {
-      language,
-      title,
-      type,
-      localeType: "",
-      revision: item.revision,
-      shortId: item.shortId,
-      multipleVersions: versionOf,
-      disabled: frontEndConfig.results.disabledResults.includes(type),
-      link,
-      files
-    };
-  });
-  if (data.tags) {
-    const contentLang = ((0, import_headers2.cookies)().get(CONTENT_LANG_KEY)?.value || EN_LANG).toLowerCase();
-    const splittedContentLang = contentLang.split("-")[0];
-    for (const [key, value] of Object.entries(data.tags)) {
-      if (!value || !value.items || value.items.length === 0) {
-        continue;
-      }
-      if (!backEndConfig.search.tags.includes(key)) {
-        continue;
-      }
-      const aux = value.items.map((item) => {
-        if (item?.shortId === void 0) return null;
-        if (Number(item.hits) === 0) return null;
-        if (item?.labels === void 0 || item?.labels.length === 0) {
-          logger.log({
-            level: "warning",
-            message: `No labels on item with id ${item.shortId} from category ${key}`
-          });
-          return null;
-        }
-        let label = "";
-        for (const labelItem of item.labels) {
-          if (labelItem.language === void 0) {
-            logger.log({
-              level: "info",
-              message: `No language on label ${labelItem.value} from category ${key}`
-            });
-            label = labelItem.value;
-            break;
-          }
-          if (labelItem.language.toLowerCase() === contentLang || labelItem.language.toLowerCase() === splittedContentLang) {
-            label = labelItem.value;
-            break;
-          }
-          label = labelItem.value;
-        }
-        return {
-          hits: item.hits,
-          total: item.total,
-          label,
-          active: false,
-          shortId: item.shortId
-        };
-      }).filter((item) => item !== null);
-      if (aux.length === 0) {
-        continue;
-      }
-      filteredTags[key] = aux;
-    }
-  }
-  return {
-    tags: filteredTags,
-    items,
-    pageInfo: data.pageInfo
-  };
-};
-var transformSuggestions = (data, query) => {
-  const suggestions = [];
-  const comparableList = [];
-  data.suggestions.forEach((item) => {
-    suggestions.push(item.value);
-    comparableList.push(item.value.toLowerCase());
-  });
-  if (!comparableList.includes(query.toLowerCase())) {
-    return [query, ...suggestions];
-  }
-  return suggestions;
-};
-
-// src/informationUnits.ts
-var InformationUnitsService = class extends BaseService {
-  constructor() {
-    super("InformationUnits/");
-  }
-  /**
-   * Retrieves a list of information units based on specified criteria.
-   * 
-   * @param options - Options for filtering and paginating the information units list
-   * @param options.queries - Optional search query string
-   * @param options.page - Optional page number for pagination (defaults to 1)
-   * @param options.fields - Optional array of fields to include in the response
-   * @param options.filters - Optional array of filter strings to apply
-   * @param options.languages - Optional array of language codes to filter by
-   * @returns A promise that resolves to the information units response
-   * @throws Error if the API request fails
-   */
-  async getList({
-    queries = "",
-    page = 1,
-    fields = [],
-    filters = [],
-    tags = [],
-    restrict = [],
-    languages = [],
-    wildcard = WILD_CARD_OPTIONS.BOTH,
-    operator = OPERATOR_OPTIONS.AND,
-    like = false
-  }) {
-    const remainFields = createParams(fields, "Fields");
-    const remainFilters = createParams(filters, "Filter");
-    const restrictions = createParams(restrict, "Restrict");
-    const remainTags = createParams(tags, "Tags");
-    const params = [
-      { key: "pageSize", value: "12" },
-      { key: "wildcard", value: wildcard.toLowerCase() },
-      { key: "PageNumber", value: page.toString() },
-      { key: "Operator", value: operator },
-      { key: "Like", value: like.toString() },
-      ...remainTags,
-      ...remainFields,
-      ...remainFilters,
-      ...restrictions
-    ];
-    if (languages.length > 0) {
-      const languageParam = `VALUES ?lang { ${languages.map((lang) => `"${lang}"`).join(" ")} } ?s iirds:language ?lang .`;
-      params.push({ key: "sparqlWhere", value: languageParam });
-    }
-    if (queries.length > 0) {
-      params.push(
-        { key: "Query", value: queries }
-      );
-    }
-    return await this.request({
-      params,
-      transformer: transformInformationUnits
-    });
-  }
-  /**
-   * Retrieves a specific information unit by its ID.
-   * Includes renditions, directory nodes, version information, titles, languages, and labels.
-   * 
-   * @param options - Options for retrieving the information unit
-   * @param options.id - The unique identifier of the information unit
-   * @returns A promise that resolves to the information unit data
-   * @throws Error if the API request fails
-   */
-  async getItem({ id, shouldGetAllFields = false }) {
-    const params = [];
-    if (!shouldGetAllFields) {
-      params.push(
-        { key: "Fields", value: "renditions" },
-        { key: "Fields", value: "directoryNodes" },
-        { key: "Fields", value: "versionOf" },
-        { key: "Fields", value: "titles" },
-        { key: "Fields", value: "languages" },
-        { key: "Fields", value: "labels" },
-        { key: "Fields", value: "packages" },
-        { key: "Fields", value: "created" },
-        { key: "Fields", value: "revision" }
-      );
-    }
-    return await this.request({
-      path: id,
-      params
-    });
-  }
-  /**
-   * Retrieves autocomplete suggestions based on a query prefix.
-   * 
-   * @param options - Options for retrieving suggestions
-   * @param options.query - The query prefix to get suggestions for
-   * @param options.language - The language of the suggestions
-   * @returns A promise that resolves to an array of suggestion strings
-   * @throws Error if the API request fails
-   */
-  async getSuggestions({ query, language }) {
-    return await this.request({
-      path: "Suggestions",
-      params: [
-        { key: "prefix", value: query },
-        { key: "lang", value: language }
-      ],
-      transformer: (data) => transformSuggestions(data, query)
-    });
-  }
-};
-
-// src/language.ts
-var import_sdk3 = require("@c-rex/core/sdk");
-var LanguageService = class extends BaseService {
-  constructor() {
-    const sdk = new import_sdk3.CrexSDK();
-    const configs = sdk.getClientConfig();
-    super(configs.languageSwitcher.endpoint);
-  }
-  /**
-   * Retrieves a list of available languages and their associated countries.
-   * Transforms the API response to include language code, country code, and original value.
-   * 
-   * @returns A promise that resolves to an array of language and country objects
-   * @throws Error if the API request fails
-   */
-  async getLanguagesAndCountries() {
-    return await this.request({
-      transformer: (data) => {
-        const countryCodeList = data.map((item) => {
-          const splittedValue = item.value.split("-");
-          const lang = splittedValue[0];
-          let country = splittedValue[0];
-          if (splittedValue.length > 1) {
-            country = splittedValue[1];
-          } else {
-            country = getCountryCodeByLang(lang);
-          }
-          return {
-            country,
-            lang,
-            value: item.value
-          };
-        });
-        return countryCodeList.sort((a, b) => {
-          return a.value.localeCompare(b.value);
-        });
-      }
-    });
-  }
-};
-
-// src/transforms/topics.ts
-var import_headers3 = require("next/headers");
-var import_logger2 = require("@c-rex/core/logger");
-var import_sdk4 = require("@c-rex/core/sdk");
-var transformTopics = async (data) => {
-  const logger = new import_logger2.CrexLogger();
-  const sdk = new import_sdk4.CrexSDK();
-  const config = sdk.getClientConfig();
-  const uiLang = ((0, import_headers3.cookies)().get(UI_LANG_KEY)?.value || config.languageSwitcher.default).toLowerCase();
-  const items = data.items.map((item) => {
-    const type = item.class.labels.filter((item2) => item2.language === EN_LANG)[0].value.toUpperCase();
-    let link = `/topics/${item.shortId}`;
-    if (config.results.articlePageLayout == "BLOG") {
-      link = `/blog/${item.shortId}`;
-    } else if (type == RESULT_TYPES.DOCUMENT) {
-      link = `/documents/${item.shortId}`;
-    }
-    let title = "NO TITLE";
-    let language = "NO LANGUAGE";
-    try {
-      if (item.titles) {
-        title = item.titles[0].value;
-        language = item.titles[0].language;
-      } else {
-        title = item.labels[0].value;
-        language = item.labels[0].language;
-      }
-    } catch {
-      logger.log({
-        level: "error",
-        message: `No label or title on item ${item.shortId}`
-      });
-    }
-    let renditionUrl = "";
-    const renditions = item.renditions.filter((item2) => item2.format == "application/xhtml+xml");
-    if (renditions.length > 0 || renditions[0] !== void 0) {
-      const filteredLinks = renditions[0].links.filter((renditionItem) => renditionItem.rel == "view");
-      if (filteredLinks.length > 0 || filteredLinks[0] !== void 0) {
-        renditionUrl = filteredLinks[0].href;
-      }
-      ;
-    }
-    ;
-    let categoryType = type;
-    if (item.applicableForTypes && item.applicableForTypes.length > 0) {
-      const splittedContentLang = uiLang.split("-")[0];
-      categoryType = item.applicableForTypes[0].labels.find((item2) => item2.language === splittedContentLang)?.value || categoryType;
-    }
-    return {
-      language,
-      title,
-      type: categoryType,
-      localeType: "",
-      shortId: item.shortId,
-      created: formatDateToLocale(item.created, uiLang),
-      disabled: config.results.disabledResults.includes(type),
-      link,
-      renditionUrl,
-      image: null,
-      description: null
-    };
-  });
-  return {
-    tags: null,
-    items,
-    pageInfo: data.pageInfo
-  };
-};
-
-// src/topics.ts
-var TopicsService = class extends BaseService {
-  constructor() {
-    super("Topics/");
-  }
-  /**
-   * Retrieves a list of topics based on specified criteria.
-   * 
-   * @param options - Options for filtering and paginating the topics list
-   * @param options.queries - Optional search query string
-   * @param options.page - Optional page number for pagination (defaults to 1)
-   * @param options.fields - Optional array of fields to include in the response
-   * @param options.filters - Optional array of filter strings to apply
-   * @param options.languages - Optional array of language codes to filter by
-   * @returns A promise that resolves to the information units response
-   * @throws Error if the API request fails
-   */
-  async getList({
-    queries = "",
-    page = 1,
-    fields = [],
-    filters = [],
-    languages = [],
-    wildcard = WILD_CARD_OPTIONS.BOTH,
-    operator = OPERATOR_OPTIONS.AND,
-    pageSize = 12
-  }) {
-    const remainFields = createParams(fields, "Fields");
-    const remainFilters = createParams(filters, "Filter");
-    const params = [
-      { key: "pageSize", value: pageSize.toString() },
-      { key: "PageNumber", value: page.toString() },
-      { key: "Sort", value: "-created;-score" },
-      { key: "Operator", value: operator },
-      { key: "wildcard", value: wildcard.toLowerCase() },
-      ...remainFields,
-      ...remainFilters
-    ];
-    if (languages.length > 0) {
-      const languageParam = `VALUES ?lang { ${languages.map((lang) => `"${lang}"`).join(" ")} } ?s iirds:language ?lang .`;
-      params.push({ key: "sparqlWhere", value: languageParam });
-    }
-    if (queries.length > 0) {
-      params.push(
-        { key: "Query", value: queries }
-      );
-    }
-    return await this.request({
-      params,
-      transformer: transformTopics
-    });
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DirectoryNodesService,
-  DocumentTypesService,
-  InformationUnitsService,
-  LanguageService,
-  RenditionsService,
-  TopicsService
-});
-//# sourceMappingURL=index.js.map