@depup/contentful 11.10.7-depup.0

package/dist/esm/contentful.js

@@ -0,0 +1,60 @@
+import axios from 'axios';
+import { getUserAgentHeader, createHttpClient } from 'contentful-sdk-core';
+import { createGlobalOptions } from './create-global-options.js';
+import { makeClient } from './make-client.js';
+import { validateResolveLinksParam, validateRemoveUnresolvedParam } from './utils/validate-params.js';
+
+/**
+ * Contentful Delivery API SDK. Allows you to create instances of a client
+ * with access to the Contentful Content Delivery API.
+ */
+/**
+ * Create a client instance
+ * @param params - Client initialization parameters
+ * @category Client
+ * @example
+ * ```typescript
+ * const contentful = require('contentful')
+ * const client = contentful.createClient({
+ *   accessToken: 'myAccessToken',
+ *   space: 'mySpaceId'
+ * })
+ * ```
+ */
+function createClient(params) {
+    if (!params.accessToken) {
+        throw new TypeError('Expected parameter accessToken');
+    }
+    if (!params.space) {
+        throw new TypeError('Expected parameter space');
+    }
+    validateResolveLinksParam(params);
+    validateRemoveUnresolvedParam(params);
+    const defaultConfig = {
+        resolveLinks: true,
+        removeUnresolved: false,
+        defaultHostname: 'cdn.contentful.com',
+        environment: 'master',
+    };
+    const config = Object.assign(Object.assign({}, defaultConfig), params);
+    const userAgentHeader = getUserAgentHeader(`contentful.js/${"0.0.0-determined-by-semantic-release"}`, config.application, config.integration);
+    config.headers = Object.assign(Object.assign({}, config.headers), { 'Content-Type': 'application/vnd.contentful.delivery.v1+json', 'X-Contentful-User-Agent': userAgentHeader });
+    const http = createHttpClient(axios, config);
+    if (!http.defaults.baseURL) {
+        throw new Error('Please define a baseURL');
+    }
+    const getGlobalOptions = createGlobalOptions({
+        space: config.space,
+        environment: config.environment,
+        spaceBaseUrl: http.defaults.baseURL,
+        environmentBaseUrl: `${http.defaults.baseURL}environments/${config.environment}`,
+    });
+    // Append environment to baseURL
+    http.defaults.baseURL = getGlobalOptions({}).environmentBaseUrl;
+    return makeClient({
+        http,
+        getGlobalOptions,
+    });
+}
+
+export { createClient };

package/dist/esm/create-contentful-api.js

@@ -0,0 +1,463 @@
+import { encodeCPAResponse } from '@contentful/content-source-maps';
+import { createRequestConfig, errorHandler } from 'contentful-sdk-core';
+import pagedSync from './paged-sync.js';
+import normalizeSearchParameters from './utils/normalize-search-parameters.js';
+import normalizeSelect from './utils/normalize-select.js';
+import resolveCircular from './utils/resolve-circular.js';
+import getQuerySelectionSet from './utils/query-selection-set.js';
+import validateTimestamp from './utils/validate-timestamp.js';
+import { validateLocaleParam, validateResolveLinksParam, validateRemoveUnresolvedParam, checkIncludeContentSourceMapsParamIsAllowed } from './utils/validate-params.js';
+import validateSearchParameters from './utils/validate-search-parameters.js';
+import { getTimelinePreviewParams } from './utils/timeline-preview-helpers.js';
+import { normalizeCursorPaginationParameters } from './utils/normalize-cursor-pagination-parameters.js';
+import { normalizeCursorPaginationResponse } from './utils/normalize-cursor-pagination-response.js';
+
+/**
+ * Contentful Delivery API Client. Contains methods which allow access to the
+ * different kinds of entities present in Contentful (Entries, Assets, etc).
+ */
+const ASSET_KEY_MAX_LIFETIME = 48 * 60 * 60;
+class NotFoundError extends Error {
+    constructor(id, environment, space) {
+        super('The resource could not be found.');
+        this.sys = {
+            type: 'Error',
+            id: 'NotFound',
+        };
+        this.details = {
+            type: 'Entry',
+            id,
+            environment,
+            space,
+        };
+    }
+}
+function createContentfulApi({ http, getGlobalOptions }, options) {
+    const notFoundError = (id = 'unknown') => {
+        return new NotFoundError(id, getGlobalOptions().environment, getGlobalOptions().space);
+    };
+    const getBaseUrl = (context) => {
+        let baseUrl = context === 'space' ? getGlobalOptions().spaceBaseUrl : getGlobalOptions().environmentBaseUrl;
+        if (!baseUrl) {
+            throw new Error('Please define baseUrl for ' + context);
+        }
+        if (!baseUrl.endsWith('/')) {
+            baseUrl += '/';
+        }
+        return baseUrl;
+    };
+    function maybeEnableSourceMaps(query = {}) {
+        var _a, _b;
+        const params = http.httpClientParams;
+        const includeContentSourceMaps = (_a = params === null || params === void 0 ? void 0 : params.includeContentSourceMaps) !== null && _a !== void 0 ? _a : (_b = params === null || params === void 0 ? void 0 : params.alphaFeatures) === null || _b === void 0 ? void 0 : _b.includeContentSourceMaps;
+        const host = params === null || params === void 0 ? void 0 : params.host;
+        const areAllowed = checkIncludeContentSourceMapsParamIsAllowed(host, includeContentSourceMaps);
+        if (areAllowed) {
+            query.includeContentSourceMaps = true;
+            // Ensure that content source maps and required attributes are selected
+            if (query.select) {
+                const selection = getQuerySelectionSet(query);
+                selection.add('sys');
+                query.select = Array.from(selection).join(',');
+            }
+        }
+        return query;
+    }
+    function maybeEnableTimelinePreview(path) {
+        const { enabled } = getTimelinePreviewParams(http.httpClientParams);
+        return enabled ? `timeline/${path}` : path;
+    }
+    function maybeAddTimelinePreviewConfigToQuery(query) {
+        const { enabled, timelinePreview } = getTimelinePreviewParams(http.httpClientParams);
+        if (enabled) {
+            if (timelinePreview === null || timelinePreview === void 0 ? void 0 : timelinePreview.release) {
+                query.release = timelinePreview.release;
+            }
+            if (timelinePreview === null || timelinePreview === void 0 ? void 0 : timelinePreview.timestamp) {
+                query.timestamp = timelinePreview.timestamp;
+            }
+        }
+        return query;
+    }
+    function maybeEncodeCPAResponse(data, config) {
+        var _a;
+        const includeContentSourceMaps = (_a = config === null || config === void 0 ? void 0 : config.params) === null || _a === void 0 ? void 0 : _a.includeContentSourceMaps;
+        if (includeContentSourceMaps) {
+            return encodeCPAResponse(data);
+        }
+        return data;
+    }
+    async function get({ context, path, config }) {
+        const baseUrl = getBaseUrl(context);
+        try {
+            const response = await http.get(baseUrl + path, config);
+            return maybeEncodeCPAResponse(response.data, config);
+        }
+        catch (error) {
+            errorHandler(error);
+        }
+    }
+    async function post({ context, path, data, config }) {
+        const baseUrl = getBaseUrl(context);
+        try {
+            const response = await http.post(baseUrl + path, data, config);
+            return response.data;
+        }
+        catch (error) {
+            errorHandler(error);
+        }
+    }
+    async function getSpace() {
+        return get({ context: 'space', path: '' });
+    }
+    async function getContentType(id) {
+        return get({
+            context: 'environment',
+            path: `content_types/${id}`,
+        });
+    }
+    async function getContentTypes(query = {}) {
+        return get({
+            context: 'environment',
+            path: 'content_types',
+            config: createRequestConfig({ query }),
+        });
+    }
+    async function getEntry(id, query = {}) {
+        return makeGetEntry(id, query, options);
+    }
+    async function getEntries(query = {}) {
+        return makeGetEntries(query, options);
+    }
+    async function getEntriesWithCursor(query = {}) {
+        const response = await makeGetEntries(normalizeCursorPaginationParameters(query), options);
+        return normalizeCursorPaginationResponse(response);
+    }
+    async function makeGetEntry(id, query, options = {
+        withAllLocales: false,
+        withoutLinkResolution: false,
+        withoutUnresolvableLinks: false,
+    }) {
+        const { withAllLocales } = options;
+        validateLocaleParam(query, withAllLocales);
+        validateResolveLinksParam(query);
+        validateRemoveUnresolvedParam(query);
+        validateSearchParameters(query);
+        return internalGetEntry(id, withAllLocales ? Object.assign(Object.assign({}, query), { locale: '*' }) : query, options);
+    }
+    async function internalGetEntry(id, query, options) {
+        if (!id) {
+            throw notFoundError(id);
+        }
+        try {
+            const response = await internalGetEntries(Object.assign({ 'sys.id': id }, maybeEnableSourceMaps(query)), options);
+            if (response.items.length > 0) {
+                return response.items[0];
+            }
+            else {
+                throw notFoundError(id);
+            }
+        }
+        catch (error) {
+            errorHandler(error);
+        }
+    }
+    async function makeGetEntries(query, options = {
+        withAllLocales: false,
+        withoutLinkResolution: false,
+        withoutUnresolvableLinks: false,
+    }) {
+        const { withAllLocales } = options;
+        validateLocaleParam(query, withAllLocales);
+        validateResolveLinksParam(query);
+        validateRemoveUnresolvedParam(query);
+        validateSearchParameters(query);
+        return internalGetEntries(withAllLocales
+            ? Object.assign(Object.assign({}, query), { locale: '*' }) : query, options);
+    }
+    function prepareQuery(query) {
+        // First, add timeline preview config if enabled
+        const withTimelinePreview = maybeAddTimelinePreviewConfigToQuery(Object.assign({}, query));
+        // Then, apply source maps and other normalizations
+        return maybeEnableSourceMaps(normalizeSearchParameters(normalizeSelect(withTimelinePreview)));
+    }
+    async function internalGetEntries(query, options) {
+        const { withoutLinkResolution, withoutUnresolvableLinks } = options;
+        try {
+            const entries = await get({
+                context: 'environment',
+                path: maybeEnableTimelinePreview('entries'),
+                config: createRequestConfig({
+                    query: prepareQuery(query),
+                }),
+            });
+            return resolveCircular(entries, {
+                resolveLinks: !withoutLinkResolution,
+                removeUnresolved: withoutUnresolvableLinks !== null && withoutUnresolvableLinks !== void 0 ? withoutUnresolvableLinks : false,
+            });
+        }
+        catch (error) {
+            errorHandler(error);
+        }
+    }
+    async function getAsset(id, query = {}) {
+        return makeGetAsset(id, query, options);
+    }
+    async function getAssets(query = {}) {
+        return makeGetAssets(query, options);
+    }
+    async function getAssetsWithCursor(query = {}) {
+        const response = await makeGetAssets(normalizeCursorPaginationParameters(query), options);
+        return normalizeCursorPaginationResponse(response);
+    }
+    async function makeGetAssets(query, options = {
+        withAllLocales: false,
+        withoutLinkResolution: false,
+        withoutUnresolvableLinks: false,
+    }) {
+        const { withAllLocales } = options;
+        validateLocaleParam(query, withAllLocales);
+        validateSearchParameters(query);
+        const localeSpecificQuery = withAllLocales ? Object.assign(Object.assign({}, query), { locale: '*' }) : query;
+        return internalGetAssets(localeSpecificQuery);
+    }
+    async function internalGetAsset(id, query) {
+        try {
+            return get({
+                context: 'environment',
+                path: maybeEnableTimelinePreview(`assets/${id}`),
+                config: createRequestConfig({ query: prepareQuery(query) }),
+            });
+        }
+        catch (error) {
+            errorHandler(error);
+        }
+    }
+    async function makeGetAsset(id, query, options = {
+        withAllLocales: false,
+        withoutLinkResolution: false,
+        withoutUnresolvableLinks: false,
+    }) {
+        const { withAllLocales } = options;
+        validateLocaleParam(query, withAllLocales);
+        validateSearchParameters(query);
+        const localeSpecificQuery = withAllLocales ? Object.assign(Object.assign({}, query), { locale: '*' }) : query;
+        return internalGetAsset(id, localeSpecificQuery);
+    }
+    async function internalGetAssets(query) {
+        try {
+            return get({
+                context: 'environment',
+                path: maybeEnableTimelinePreview('assets'),
+                config: createRequestConfig({
+                    query: prepareQuery(query),
+                }),
+            });
+        }
+        catch (error) {
+            errorHandler(error);
+        }
+    }
+    async function getTag(id) {
+        return get({
+            context: 'environment',
+            path: `tags/${id}`,
+        });
+    }
+    async function getTags(query = {}) {
+        validateSearchParameters(query);
+        return get({
+            context: 'environment',
+            path: 'tags',
+            config: createRequestConfig({ query: normalizeSearchParameters(normalizeSelect(query)) }),
+        });
+    }
+    async function createAssetKey(expiresAt) {
+        try {
+            const now = Math.floor(Date.now() / 1000);
+            const currentMaxLifetime = now + ASSET_KEY_MAX_LIFETIME;
+            validateTimestamp('expiresAt', expiresAt, { maximum: currentMaxLifetime, now });
+        }
+        catch (error) {
+            errorHandler(error);
+        }
+        return post({
+            context: 'environment',
+            path: 'asset_keys',
+            data: { expiresAt },
+        });
+    }
+    async function getLocales(query = {}) {
+        validateSearchParameters(query);
+        return get({
+            context: 'environment',
+            path: 'locales',
+            config: createRequestConfig({ query: normalizeSelect(query) }),
+        });
+    }
+    async function sync(query, syncOptions = { paginate: true }) {
+        return makePagedSync(query, syncOptions, options);
+    }
+    async function makePagedSync(query, syncOptions, options = {
+        withAllLocales: false,
+        withoutLinkResolution: false,
+        withoutUnresolvableLinks: false,
+    }) {
+        validateResolveLinksParam(query);
+        validateRemoveUnresolvedParam(query);
+        const combinedOptions = Object.assign(Object.assign({}, syncOptions), options);
+        switchToEnvironment(http);
+        return pagedSync(http, query, combinedOptions);
+    }
+    function parseEntries(data) {
+        return makeParseEntries(data, options);
+    }
+    function makeParseEntries(data, options = {
+        withAllLocales: false,
+        withoutLinkResolution: false,
+        withoutUnresolvableLinks: false,
+    }) {
+        return internalParseEntries(data, options);
+    }
+    function internalParseEntries(data, options) {
+        const { withoutLinkResolution, withoutUnresolvableLinks } = options;
+        return resolveCircular(data, {
+            resolveLinks: !withoutLinkResolution,
+            removeUnresolved: withoutUnresolvableLinks !== null && withoutUnresolvableLinks !== void 0 ? withoutUnresolvableLinks : false,
+        });
+    }
+    function getConceptScheme(id, query = {}) {
+        return internalGetConceptScheme(id, query);
+    }
+    async function internalGetConceptScheme(id, query = {}) {
+        try {
+            return get({
+                context: 'environment',
+                path: `taxonomy/concept-schemes/${id}`,
+                config: createRequestConfig({
+                    query: normalizeSearchParameters(normalizeSelect(query)),
+                }),
+            });
+        }
+        catch (error) {
+            errorHandler(error);
+        }
+    }
+    function getConceptSchemes(query = {}) {
+        return internalGetConceptSchemes(query);
+    }
+    async function internalGetConceptSchemes(query = {}) {
+        try {
+            return get({
+                context: 'environment',
+                path: 'taxonomy/concept-schemes',
+                config: createRequestConfig({
+                    query: normalizeSearchParameters(normalizeSelect(query)),
+                }),
+            });
+        }
+        catch (error) {
+            errorHandler(error);
+        }
+    }
+    function getConcept(id, query = {}) {
+        return internalGetConcept(id, query);
+    }
+    async function internalGetConcept(id, query = {}) {
+        try {
+            return get({
+                context: 'environment',
+                path: `taxonomy/concepts/${id}`,
+                config: createRequestConfig({
+                    query: normalizeSearchParameters(normalizeSelect(query)),
+                }),
+            });
+        }
+        catch (error) {
+            errorHandler(error);
+        }
+    }
+    function getConcepts(query = {}) {
+        return internalGetConcepts(query);
+    }
+    async function internalGetConcepts(query = {}) {
+        try {
+            return get({
+                context: 'environment',
+                path: 'taxonomy/concepts',
+                config: createRequestConfig({
+                    query: normalizeSearchParameters(normalizeSelect(query)),
+                }),
+            });
+        }
+        catch (error) {
+            errorHandler(error);
+        }
+    }
+    function getConceptAncestors(id, query = {}) {
+        return internalGetConceptAncestors(id, query);
+    }
+    async function internalGetConceptAncestors(id, query = {}) {
+        try {
+            return get({
+                context: 'environment',
+                path: `taxonomy/concepts/${id}/ancestors`,
+                config: createRequestConfig({
+                    query: normalizeSearchParameters(normalizeSelect(query)),
+                }),
+            });
+        }
+        catch (error) {
+            errorHandler(error);
+        }
+    }
+    function getConceptDescendants(id, query = {}) {
+        return internalGetConceptDescendants(id, query);
+    }
+    async function internalGetConceptDescendants(id, query = {}) {
+        try {
+            return get({
+                context: 'environment',
+                path: `taxonomy/concepts/${id}/descendants`,
+                config: createRequestConfig({
+                    query: normalizeSearchParameters(normalizeSelect(query)),
+                }),
+            });
+        }
+        catch (error) {
+            errorHandler(error);
+        }
+    }
+    /*
+     * Switches BaseURL to use /environments path
+     * */
+    function switchToEnvironment(http) {
+        http.defaults.baseURL = getGlobalOptions().environmentBaseUrl;
+    }
+    return {
+        version: "0.0.0-determined-by-semantic-release",
+        getSpace,
+        getContentType,
+        getContentTypes,
+        getAsset,
+        getAssets,
+        getAssetsWithCursor,
+        getTag,
+        getTags,
+        getLocales,
+        parseEntries,
+        sync,
+        getEntry,
+        getEntries,
+        getEntriesWithCursor,
+        getConceptScheme,
+        getConceptSchemes,
+        getConcept,
+        getConcepts,
+        getConceptAncestors,
+        getConceptDescendants,
+        createAssetKey,
+    };
+}
+
+export { createContentfulApi as default };

package/dist/esm/create-global-options.js

@@ -0,0 +1,21 @@
+/**
+ * @param globalSettings - Global library settings
+ * @returns getGlobalSettings - Method returning client settings
+ * @category Client
+ */
+function createGlobalOptions(globalSettings) {
+    /**
+     * Method merging pre-configured global options and provided local parameters
+     * @param query - regular query object used for collection endpoints
+     * @param query.environment - optional name of the environment
+     * @param query.space - optional space ID
+     * @param query.spaceBaseUrl - optional base URL for the space
+     * @param query.environmentBaseUrl - optional base URL for the environment
+     * @returns global options
+     */
+    return function getGlobalOptions(query) {
+        return Object.assign({}, globalSettings, query);
+    };
+}
+
+export { createGlobalOptions };

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export { createClient } from './contentful.js';
+export { createGlobalOptions } from './create-global-options.js';
+import 'json-stringify-safe';
+import 'contentful-resolve-response';

package/dist/esm/make-client.js

@@ -0,0 +1,52 @@
+import createContentfulApi from './create-contentful-api.js';
+
+function create({ http, getGlobalOptions }, options, makeInnerClient) {
+    const client = createContentfulApi({
+        http,
+        getGlobalOptions,
+    }, options);
+    const response = client ? client : {};
+    Object.defineProperty(response, 'withAllLocales', {
+        get: () => makeInnerClient(Object.assign(Object.assign({}, options), { withAllLocales: true })),
+    });
+    Object.defineProperty(response, 'withoutLinkResolution', {
+        get: () => makeInnerClient(Object.assign(Object.assign({}, options), { withoutLinkResolution: true })),
+    });
+    Object.defineProperty(response, 'withoutUnresolvableLinks', {
+        get: () => makeInnerClient(Object.assign(Object.assign({}, options), { withoutUnresolvableLinks: true })),
+    });
+    return Object.create(response);
+}
+const makeClient = ({ http, getGlobalOptions, }) => {
+    function makeInnerClient(options) {
+        return create({ http, getGlobalOptions }, options, makeInnerClient);
+    }
+    const client = createContentfulApi({ http, getGlobalOptions }, {
+        withoutLinkResolution: false,
+        withAllLocales: false,
+        withoutUnresolvableLinks: false,
+    });
+    return Object.assign(Object.assign({}, client), { get withAllLocales() {
+            return makeInnerClient({
+                withAllLocales: true,
+                withoutLinkResolution: false,
+                withoutUnresolvableLinks: false,
+            });
+        },
+        get withoutLinkResolution() {
+            return makeInnerClient({
+                withAllLocales: false,
+                withoutLinkResolution: true,
+                withoutUnresolvableLinks: false,
+            });
+        },
+        get withoutUnresolvableLinks() {
+            return makeInnerClient({
+                withAllLocales: false,
+                withoutLinkResolution: false,
+                withoutUnresolvableLinks: true,
+            });
+        } });
+};
+
+export { makeClient };

package/dist/esm/mixins/stringify-safe.js

@@ -0,0 +1,23 @@
+import jsonStringifySafe from 'json-stringify-safe';
+
+function mixinStringifySafe(data) {
+    return Object.defineProperty(data, 'stringifySafe', {
+        enumerable: false,
+        configurable: false,
+        writable: false,
+        value: function (serializer = null, indent = '') {
+            return jsonStringifySafe(this, serializer, indent, (key, value) => {
+                return {
+                    sys: {
+                        type: 'Link',
+                        linkType: 'Entry',
+                        id: value.sys.id,
+                        circular: true,
+                    },
+                };
+            });
+        },
+    });
+}
+
+export { mixinStringifySafe as default };