contentful-management 11.49.0-beta.2 → 11.49.0

package/dist/es-modules/common-types.js

@@ -0,0 +1,61 @@
+/**
+ * Link is a reference object to another entity that can be resolved using tools such as contentful-resolve
+ */
+
+/**
+ * ResourceLink is a reference object to another entity outside of the current space/environment
+ */
+
+/** String will be in ISO8601 datetime format e.g. 2013-06-26T13:57:24Z */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// Base interface for shared fields
+
+// Interfaces for each “exclusive” shape
+
+// Helper type for creating property paths with comparison operators
+// For example "sys.createdAt[gte]", P = sys.createdAt, O = gte
+
+// Helper types to ensure only one start operator can be used and only one end operator can be used
+
+// Type for valid date range combinations - only start, only end, or both
+
+/**
+ * @private
+ */
+
+/**
+ * @private
+ */
+
+/**
+ * @private
+ */
+
+/**
+ * @private
+ */
+
+/**
+ * @private
+ */
+
+/**
+ * @private
+ */
+
+/**
+ * @private
+ */
+
+/**
+ * @private
+ */
+
+/** Base interface for all Payload interfaces. Used as part of the MakeRequestOptions to simplify payload definitions. */
+
+export let ScheduledActionReferenceFilters = /*#__PURE__*/function (ScheduledActionReferenceFilters) {
+  ScheduledActionReferenceFilters["contentTypeAnnotationNotIn"] = "sys.contentType.metadata.annotations.ContentType[nin]";
+  return ScheduledActionReferenceFilters;
+}({});

package/dist/es-modules/common-utils.js

@@ -0,0 +1,30 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+
+import { toPlainObject } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+/**
+ * @private
+ */
+export const wrapCollection = fn => (makeRequest, data, ...rest) => {
+  const collectionData = toPlainObject(copy(data));
+  // @ts-expect-error
+  collectionData.items = collectionData.items.map(entity => fn(makeRequest, entity, ...rest));
+  // @ts-expect-error
+  return collectionData;
+};
+export const wrapCursorPaginatedCollection = fn => (makeRequest, data, ...rest) => {
+  const collectionData = toPlainObject(copy(data));
+  // @ts-expect-error
+  collectionData.items = collectionData.items.map(entity => fn(makeRequest, entity, ...rest));
+  // @ts-expect-error
+  return collectionData;
+};
+export function isSuccessful(statusCode) {
+  return statusCode < 300;
+}
+export function shouldRePoll(statusCode) {
+  return [404, 422, 429, 400].includes(statusCode);
+}
+export async function waitFor(ms = 1000) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/es-modules/constants/editor-interface-defaults/controls-defaults.js

@@ -0,0 +1,255 @@
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { in_ } from './types';
+const DROPDOWN_TYPES = ['Text', 'Symbol', 'Integer', 'Number', 'Boolean'];
+const INTERNAL_TO_API = {
+  Symbol: {
+    type: 'Symbol'
+  },
+  Text: {
+    type: 'Text'
+  },
+  RichText: {
+    type: 'RichText'
+  },
+  Integer: {
+    type: 'Integer'
+  },
+  Number: {
+    type: 'Number'
+  },
+  Boolean: {
+    type: 'Boolean'
+  },
+  Date: {
+    type: 'Date'
+  },
+  Location: {
+    type: 'Location'
+  },
+  Object: {
+    type: 'Object'
+  },
+  File: {
+    type: 'File'
+  },
+  Entry: {
+    type: 'Link',
+    linkType: 'Entry'
+  },
+  Asset: {
+    type: 'Link',
+    linkType: 'Asset'
+  },
+  Resource: {
+    type: 'ResourceLink'
+  },
+  Symbols: {
+    type: 'Array',
+    items: {
+      type: 'Symbol'
+    }
+  },
+  Entries: {
+    type: 'Array',
+    items: {
+      type: 'Link',
+      linkType: 'Entry'
+    }
+  },
+  Assets: {
+    type: 'Array',
+    items: {
+      type: 'Link',
+      linkType: 'Asset'
+    }
+  },
+  Resources: {
+    type: 'Array',
+    items: {
+      type: 'ResourceLink'
+    }
+  }
+};
+export const FIELD_TYPES = Object.keys(INTERNAL_TO_API);
+
+/**
+ * Returns an internal string identifier for an API field object.
+ *
+ * We use this string as a simplified reference to field types.
+ * Possible values are:
+ *
+ * - Symbol
+ * - Symbols
+ * - Text
+ * - RichText
+ * - Integer
+ * - Number
+ * - Boolean
+ * - Date
+ * - Location
+ * - Object
+ * - Entry
+ * - Entries
+ * - Asset
+ * - Assets
+ * - File
+ */
+export function toInternalFieldType(api) {
+  return FIELD_TYPES.find(key => {
+    const internalApi = INTERNAL_TO_API[key];
+    const stripped = {
+      type: api.type,
+      linkType: api.linkType,
+      items: api.items
+    };
+    if (stripped.items) {
+      stripped.items = {
+        type: stripped.items.type,
+        linkType: stripped.items.linkType
+      };
+    }
+    if (internalApi.type === 'Link') {
+      return internalApi.linkType === stripped.linkType;
+    }
+    if (internalApi.type === 'Array' && internalApi.items && stripped.items) {
+      if (internalApi.items.type === 'Link') {
+        return internalApi.items.linkType === stripped.items.linkType;
+      }
+      return internalApi.items.type === stripped.items.type;
+    }
+    return internalApi.type === stripped.type;
+  });
+}
+export const DEFAULTS_WIDGET = {
+  Text: {
+    widgetId: 'markdown'
+  },
+  Symbol: {
+    widgetId: 'singleLine'
+  },
+  Integer: {
+    widgetId: 'numberEditor'
+  },
+  Number: {
+    widgetId: 'numberEditor'
+  },
+  Boolean: {
+    widgetId: 'boolean'
+  },
+  Date: {
+    widgetId: 'datePicker'
+  },
+  Location: {
+    widgetId: 'locationEditor'
+  },
+  Object: {
+    widgetId: 'objectEditor'
+  },
+  RichText: {
+    widgetId: 'richTextEditor'
+  },
+  Entry: {
+    widgetId: 'entryLinkEditor'
+  },
+  Asset: {
+    widgetId: 'assetLinkEditor'
+  },
+  Symbols: {
+    widgetId: 'tagEditor'
+  },
+  Entries: {
+    widgetId: 'entryLinksEditor'
+  },
+  Assets: {
+    widgetId: 'assetLinksEditor'
+  },
+  File: {
+    widgetId: 'fileEditor'
+  },
+  Resource: {
+    widgetId: 'resourceLinkEditor'
+  },
+  Resources: {
+    widgetId: 'resourceLinksEditor'
+  }
+};
+export const DEFAULTS_SETTINGS = {
+  Boolean: {
+    falseLabel: 'No',
+    helpText: null,
+    trueLabel: 'Yes'
+  },
+  Date: {
+    helpText: null,
+    ampm: '24',
+    format: 'timeZ'
+  },
+  Entry: {
+    helpText: null,
+    showCreateEntityAction: true,
+    showLinkEntityAction: true
+  },
+  Asset: {
+    helpText: null,
+    showCreateEntityAction: true,
+    showLinkEntityAction: true
+  },
+  Entries: {
+    helpText: null,
+    bulkEditing: false,
+    showCreateEntityAction: true,
+    showLinkEntityAction: true
+  },
+  Assets: {
+    helpText: null,
+    showCreateEntityAction: true,
+    showLinkEntityAction: true
+  }
+};
+function getDefaultWidget(field, fieldId) {
+  const defaultWidget = _objectSpread(_objectSpread({}, DEFAULTS_WIDGET[field]), {}, {
+    settings: {
+      helpText: null
+    },
+    widgetNamespace: 'builtin',
+    fieldId
+  });
+  if (in_(field, DEFAULTS_SETTINGS)) {
+    defaultWidget.settings = _objectSpread(_objectSpread({}, defaultWidget.settings), DEFAULTS_SETTINGS[field]);
+  }
+  return defaultWidget;
+}
+
+/**
+ * Given our internal identifier returns a minimal API field object.
+ */
+export function toApiFieldType(internal) {
+  return INTERNAL_TO_API[internal];
+}
+
+/*
+ * Gets the default widget ID for a field:
+ * - If a field allows predefined values then `dropdown` widget is used
+ *   in the presence of the `in` validation.
+ * - If a Text field is a title then the `singleLine` widget is used.
+ * - Otherwise a simple type-to-editor mapping is used.
+ */
+export default function getDefaultControlOfField(field) {
+  const fieldType = toInternalFieldType(field);
+  if (!fieldType) {
+    throw new Error('Invalid field type');
+  }
+  const hasInValidation = (field.validations || []).find(v => 'in' in v);
+  if (hasInValidation && DROPDOWN_TYPES.includes(fieldType)) {
+    return {
+      widgetId: 'dropdown',
+      fieldId: field.id,
+      widgetNamespace: 'builtin'
+    };
+  }
+  return getDefaultWidget(fieldType, field.id);
+}

package/dist/es-modules/constants/editor-interface-defaults/editors-defaults.js

@@ -0,0 +1,34 @@
+import { DEFAULT_EDITOR_ID, WidgetNamespace } from './types';
+export const EntryEditorWidgetTypes = {
+  DEFAULT_EDITOR: {
+    name: 'Editor',
+    id: DEFAULT_EDITOR_ID,
+    icon: 'Entry'
+  },
+  REFERENCE_TREE: {
+    name: 'References',
+    id: 'reference-tree',
+    icon: 'References'
+  },
+  TAGS_EDITOR: {
+    name: 'Tags',
+    id: 'tags-editor',
+    icon: 'Tags'
+  }
+};
+const DefaultEntryEditor = {
+  widgetId: EntryEditorWidgetTypes.DEFAULT_EDITOR.id,
+  widgetNamespace: WidgetNamespace.EDITOR_BUILTIN,
+  name: EntryEditorWidgetTypes.DEFAULT_EDITOR.name
+};
+const ReferencesEntryEditor = {
+  widgetId: EntryEditorWidgetTypes.REFERENCE_TREE.id,
+  widgetNamespace: WidgetNamespace.EDITOR_BUILTIN,
+  name: EntryEditorWidgetTypes.REFERENCE_TREE.name
+};
+const TagsEditor = {
+  widgetId: EntryEditorWidgetTypes.TAGS_EDITOR.id,
+  widgetNamespace: WidgetNamespace.EDITOR_BUILTIN,
+  name: EntryEditorWidgetTypes.TAGS_EDITOR.name
+};
+export const EntryConfiguration = [DefaultEntryEditor, ReferencesEntryEditor, TagsEditor];

package/dist/es-modules/constants/editor-interface-defaults/index.js

@@ -0,0 +1,9 @@
+import { SidebarAssetConfiguration, SidebarEntryConfiguration } from './sidebar-defaults';
+import { EntryConfiguration } from './editors-defaults';
+import getDefaultControlOfField from './controls-defaults';
+export default {
+  SidebarEntryConfiguration,
+  SidebarAssetConfiguration,
+  EntryConfiguration,
+  getDefaultControlOfField
+};

package/dist/es-modules/constants/editor-interface-defaults/sidebar-defaults.js

@@ -0,0 +1,57 @@
+import { WidgetNamespace } from './types';
+const SidebarWidgetTypes = {
+  USERS: 'users-widget',
+  CONTENT_PREVIEW: 'content-preview-widget',
+  TRANSLATION: 'translation-widget',
+  INCOMING_LINKS: 'incoming-links-widget',
+  PUBLICATION: 'publication-widget',
+  RELEASES: 'releases-widget',
+  VERSIONS: 'versions-widget',
+  INFO_PANEL: 'info-panel',
+  JOBS: 'jobs-widget',
+  COMMENTS_PANEL: 'comments-panel'
+};
+const Publication = {
+  widgetId: SidebarWidgetTypes.PUBLICATION,
+  widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+  name: 'Publish & Status',
+  description: 'Built-in - View entry status, publish, etc.'
+};
+const Releases = {
+  widgetId: SidebarWidgetTypes.RELEASES,
+  widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+  name: 'Release',
+  description: 'Built-in - View release, add to it, etc.'
+};
+const ContentPreview = {
+  widgetId: SidebarWidgetTypes.CONTENT_PREVIEW,
+  widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+  name: 'Preview',
+  description: 'Built-in - Displays preview functionality.'
+};
+const Links = {
+  widgetId: SidebarWidgetTypes.INCOMING_LINKS,
+  widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+  name: 'Links',
+  description: 'Built-in - Shows where an entry is linked.'
+};
+const Translation = {
+  widgetId: SidebarWidgetTypes.TRANSLATION,
+  widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+  name: 'Translation',
+  description: 'Built-in - Manage which translations are visible.'
+};
+const Versions = {
+  widgetId: SidebarWidgetTypes.VERSIONS,
+  widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+  name: 'Versions',
+  description: 'Built-in - View previously published versions. Available only for master environment.'
+};
+const Users = {
+  widgetId: SidebarWidgetTypes.USERS,
+  widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+  name: 'Users',
+  description: 'Built-in - Displays users on the same entry.'
+};
+export const SidebarEntryConfiguration = [Publication, Releases, ContentPreview, Links, Translation, Versions, Users];
+export const SidebarAssetConfiguration = [Publication, Releases, Links, Translation, Users];

package/dist/es-modules/constants/editor-interface-defaults/types.js

@@ -0,0 +1,14 @@
+export let WidgetNamespace = /*#__PURE__*/function (WidgetNamespace) {
+  WidgetNamespace["BUILTIN"] = "builtin";
+  WidgetNamespace["EXTENSION"] = "extension";
+  WidgetNamespace["SIDEBAR_BUILTIN"] = "sidebar-builtin";
+  WidgetNamespace["APP"] = "app";
+  WidgetNamespace["EDITOR_BUILTIN"] = "editor-builtin";
+  return WidgetNamespace;
+}({});
+export const DEFAULT_EDITOR_ID = 'default-editor';
+
+/**
+ * @private
+ */
+export const in_ = (key, object) => key in object;

package/dist/es-modules/contentful-management.js

@@ -0,0 +1,66 @@
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * Contentful Management API SDK. Allows you to create instances of a client
+ * with access to the Contentful Content Management API.
+ * @packageDocumentation
+ */
+
+import { getUserAgentHeader } from 'contentful-sdk-core';
+import { createAdapter } from './create-adapter';
+import createContentfulApi from './create-contentful-api';
+import { createPlainClient } from './plain/plain-client';
+import * as editorInterfaceDefaults from './constants/editor-interface-defaults';
+export { asIterator } from './plain/as-iterator';
+export { fetchAll } from './plain/pagination-helper';
+export { isDraft, isPublished, isUpdated } from './plain/checks';
+export { createClient };
+export { RestAdapter } from './adapters/REST/rest-adapter';
+export { makeRequest } from './adapters/REST/make-request';
+export { editorInterfaceDefaults };
+export * from './export-types';
+
+/**
+ * @deprecated
+ */
+
+/**
+ * Create a client instance
+ * @param params - Client initialization parameters
+ *
+ * ```javascript
+ * const client = contentfulManagement.createClient({
+ *  accessToken: 'myAccessToken'
+ * })
+ * ```
+ */
+
+// Usually, overloads with more specific signatures should come first but some IDEs are often not able to handle overloads with separate TSDocs correctly
+/**
+ * @deprecated The `alphaFeatures` option is no longer supported. Please use the function without this option.
+ */
+
+function createClient(params, opts = {}) {
+  const sdkMain = opts.type === 'plain' ? 'contentful-management-plain.js' : 'contentful-management.js';
+  const userAgent = getUserAgentHeader(
+  // @ts-expect-error
+  `${sdkMain}/${"11.49.0"}`, params.application, params.integration, params.feature);
+  const adapter = createAdapter(_objectSpread(_objectSpread({}, params), {}, {
+    userAgent
+  }));
+
+  // Parameters<?> and ReturnType<?> only return the types of the last overload
+  // https://github.com/microsoft/TypeScript/issues/26591
+  // @ts-expect-error
+  const makeRequest = options => adapter.makeRequest(_objectSpread(_objectSpread({}, options), {}, {
+    userAgent
+  }));
+  if (opts.type === 'plain') {
+    return createPlainClient(makeRequest, opts.defaults);
+  } else {
+    return createContentfulApi(makeRequest);
+  }
+}

package/dist/es-modules/create-adapter.js

@@ -0,0 +1,16 @@
+/**
+ * @packageDocumentation
+ * @hidden
+ */
+
+import { RestAdapter } from './adapters/REST/rest-adapter';
+/**
+ * @private
+ */
+export function createAdapter(params) {
+  if ('apiAdapter' in params) {
+    return params.apiAdapter;
+  } else {
+    return new RestAdapter(params);
+  }
+}