contentful-management 12.0.0-beta.1 → 12.0.0-beta.3

package/dist/cjs/adapters/REST/endpoints/upload-credentials.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var uploadHttpClient = require('../../../upload-http-client.js');
+var raw = require('./raw.js');
+
+const getBaseUrl = (params) => {
+    var _a;
+    return `/spaces/${params.spaceId}/environments/${(_a = params.environmentId) !== null && _a !== void 0 ? _a : 'master'}/upload_credentials`;
+};
+const create = (http, params) => {
+    const httpUpload = uploadHttpClient.getUploadHttpClient(http);
+    const path = getBaseUrl(params);
+    return raw.post(httpUpload, path);
+};
+
+exports.create = create;

package/dist/cjs/adapters/REST/endpoints/upload.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var uploadHttpClient = require('../../../upload-http-client.js');
+var raw = require('./raw.js');
+
+const getBaseUploadUrl = (params) => {
+    const spacePath = `/spaces/${params.spaceId}/uploads`;
+    const environmentPath = `/spaces/${params.spaceId}/environments/${params.environmentId}/uploads`;
+    const path = params.environmentId ? environmentPath : spacePath;
+    return path;
+};
+const getEntityUploadUrl = (params) => {
+    const path = getBaseUploadUrl(params);
+    return path + `/${params.uploadId}`;
+};
+const create = (http, params, data) => {
+    const httpUpload = uploadHttpClient.getUploadHttpClient(http);
+    const { file } = data;
+    if (!file) {
+        return Promise.reject(new Error('Unable to locate a file to upload.'));
+    }
+    const path = getBaseUploadUrl(params);
+    return raw.post(httpUpload, path, file, {
+        headers: {
+            'Content-Type': 'application/octet-stream',
+        },
+    });
+};
+const del = (http, params) => {
+    const httpUpload = uploadHttpClient.getUploadHttpClient(http);
+    const path = getEntityUploadUrl(params);
+    return raw.del(httpUpload, path);
+};
+const get = (http, params) => {
+    const httpUpload = uploadHttpClient.getUploadHttpClient(http);
+    const path = getEntityUploadUrl(params);
+    return raw.get(httpUpload, path);
+};
+
+exports.create = create;
+exports.del = del;
+exports.get = get;

package/dist/cjs/adapters/REST/endpoints/usage.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var raw = require('./raw.js');
+
+const getManyForSpace = (http, params) => {
+    return raw.get(http, `/organizations/${params.organizationId}/space_periodic_usages`, {
+        params: params.query,
+    });
+};
+const getManyForOrganization = (http, params) => {
+    return raw.get(http, `/organizations/${params.organizationId}/organization_periodic_usages`, {
+        params: params.query,
+    });
+};
+
+exports.getManyForOrganization = getManyForOrganization;
+exports.getManyForSpace = getManyForSpace;

package/dist/cjs/adapters/REST/endpoints/user-ui-config.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var copy = require('fast-copy');
+var raw = require('./raw.js');
+
+const getUrl = (params) => `/spaces/${params.spaceId}/environments/${params.environmentId}/ui_config/me`;
+const get = (http, params) => {
+    return raw.get(http, getUrl(params));
+};
+const update = (http, params, rawData) => {
+    var _a;
+    const data = copy(rawData);
+    delete data.sys;
+    return raw.put(http, getUrl(params), data, {
+        headers: {
+            'X-Contentful-Version': (_a = rawData.sys.version) !== null && _a !== void 0 ? _a : 0,
+        },
+    });
+};
+
+exports.get = get;
+exports.update = update;

package/dist/cjs/adapters/REST/endpoints/user.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var raw = require('./raw.js');
+
+const getForSpace = (http, params) => {
+    return raw.get(http, `/spaces/${params.spaceId}/users/${params.userId}`);
+};
+const getCurrent = (http, params) => raw.get(http, `/users/me`, { params: params === null || params === void 0 ? void 0 : params.query });
+const getManyForSpace = (http, params) => {
+    return raw.get(http, `/spaces/${params.spaceId}/users`, {
+        params: params.query,
+    });
+};
+const getForOrganization = (http, params) => {
+    return raw.get(http, `/organizations/${params.organizationId}/users/${params.userId}`);
+};
+const getManyForOrganization = (http, params) => {
+    return raw.get(http, `/organizations/${params.organizationId}/users`, {
+        params: params.query,
+    });
+};
+
+exports.getCurrent = getCurrent;
+exports.getForOrganization = getForOrganization;
+exports.getForSpace = getForSpace;
+exports.getManyForOrganization = getManyForOrganization;
+exports.getManyForSpace = getManyForSpace;

package/dist/cjs/adapters/REST/endpoints/utils.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var tslib = require('tslib');
+
+function normalizeSelect(query) {
+    if (query && query.select && !/sys/i.test(query.select)) {
+        return Object.assign(Object.assign({}, query), { select: query.select + ',sys' });
+    }
+    return query;
+}
+function normalizeSpaceId(query) {
+    if (query && query.spaceId) {
+        const { spaceId } = query, rest = tslib.__rest(query, ["spaceId"]);
+        return Object.assign(Object.assign({}, rest), { 'sys.space.sys.id[in]': spaceId });
+    }
+    return query;
+}
+
+exports.normalizeSelect = normalizeSelect;
+exports.normalizeSpaceId = normalizeSpaceId;

package/dist/cjs/adapters/REST/endpoints/webhook.cjs

@@ -0,0 +1,98 @@
+'use strict';
+
+var copy = require('fast-copy');
+var raw = require('./raw.js');
+var utils = require('./utils.js');
+
+const getBaseUrl = (params) => `/spaces/${params.spaceId}/webhook_definitions`;
+const getWebhookCallBaseUrl = (params) => `/spaces/${params.spaceId}/webhooks`;
+const getWebhookUrl = (params) => `${getBaseUrl(params)}/${params.webhookDefinitionId}`;
+const getWebhookCallUrl = (params) => `${getWebhookCallBaseUrl(params)}/${params.webhookDefinitionId}/calls`;
+const getWebhookCallDetailsUrl = (params) => `${getWebhookCallBaseUrl(params)}/${params.webhookDefinitionId}/calls/${params.callId}`;
+const getWebhookHealthUrl = (params) => `${getWebhookCallBaseUrl(params)}/${params.webhookDefinitionId}/health`;
+const getWebhookSettingsUrl = (params) => `/spaces/${params.spaceId}/webhook_settings`;
+const getWebhookSigningSecretUrl = (params) => `${getWebhookSettingsUrl(params)}/signing_secret`;
+const getWebhookRetryPolicyUrl = (params) => `${getWebhookSettingsUrl(params)}/retry_policy`;
+const get = (http, params) => {
+    return raw.get(http, getWebhookUrl(params));
+};
+const getManyCallDetails = (http, params) => {
+    return raw.get(http, getWebhookCallUrl(params), {
+        params: utils.normalizeSelect(params.query),
+    });
+};
+const getCallDetails = (http, params) => {
+    return raw.get(http, getWebhookCallDetailsUrl(params));
+};
+const getHealthStatus = (http, params) => {
+    return raw.get(http, getWebhookHealthUrl(params));
+};
+const getMany = (http, params) => {
+    return raw.get(http, getBaseUrl(params), {
+        params: utils.normalizeSelect(params.query),
+    });
+};
+const getSigningSecret = (http, params) => {
+    return raw.get(http, getWebhookSigningSecretUrl(params));
+};
+/**
+ * @deprecated The EAP for this feature has ended. This method will be removed in the next major version.
+ */
+const getRetryPolicy = (http, params) => {
+    return raw.get(http, getWebhookRetryPolicyUrl(params));
+};
+const create = (http, params, rawData, headers) => {
+    const data = copy(rawData);
+    return raw.post(http, getBaseUrl(params), data, { headers });
+};
+const createWithId = (http, params, rawData, headers) => {
+    const data = copy(rawData);
+    return raw.put(http, getWebhookUrl(params), data, { headers });
+};
+const update = async (http, params, rawData, headers) => {
+    var _a;
+    const data = copy(rawData);
+    delete data.sys;
+    return raw.put(http, getWebhookUrl(params), data, {
+        headers: Object.assign({ 'X-Contentful-Version': (_a = rawData.sys.version) !== null && _a !== void 0 ? _a : 0 }, headers),
+    });
+};
+const upsertSigningSecret = async (http, params, rawData) => {
+    const data = copy(rawData);
+    return raw.put(http, getWebhookSigningSecretUrl(params), data);
+};
+/**
+ * @deprecated The EAP for this feature has ended. This method will be removed in the next major version.
+ */
+const upsertRetryPolicy = async (http, params, rawData) => {
+    const data = copy(rawData);
+    return raw.put(http, getWebhookRetryPolicyUrl(params), data);
+};
+const del = (http, params) => {
+    return raw.del(http, getWebhookUrl(params));
+};
+const deleteSigningSecret = async (http, params) => {
+    return raw.del(http, getWebhookSigningSecretUrl(params));
+};
+/**
+ * @deprecated The EAP for this feature has ended. This method will be removed in the next major version.
+ */
+const deleteRetryPolicy = async (http, params) => {
+    return raw.del(http, getWebhookRetryPolicyUrl(params));
+};
+
+exports.create = create;
+exports.createWithId = createWithId;
+exports.del = del;
+exports.deleteRetryPolicy = deleteRetryPolicy;
+exports.deleteSigningSecret = deleteSigningSecret;
+exports.get = get;
+exports.getCallDetails = getCallDetails;
+exports.getHealthStatus = getHealthStatus;
+exports.getMany = getMany;
+exports.getManyCallDetails = getManyCallDetails;
+exports.getRetryPolicy = getRetryPolicy;
+exports.getSigningSecret = getSigningSecret;
+exports.update = update;
+exports.upsertRetryPolicy = upsertRetryPolicy;
+exports.upsertSigningSecret = upsertSigningSecret;

package/dist/cjs/adapters/REST/endpoints/workflow-definition.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+var tslib = require('tslib');
+var copy = require('fast-copy');
+var raw = require('./raw.js');
+
+const getBaseUrl = (params) => `/spaces/${params.spaceId}/environments/${params.environmentId}/workflow_definitions`;
+const getWorkflowDefinitionUrl = (params) => `${getBaseUrl(params)}/${params.workflowDefinitionId}`;
+const get = (http, params, headers) => raw.get(http, getWorkflowDefinitionUrl(params), {
+    headers,
+});
+const getMany = (http, params, headers) => raw.get(http, getBaseUrl(params), {
+    headers,
+    params: params.query,
+});
+const create = (http, params, rawData, headers) => {
+    const data = copy(rawData);
+    return raw.post(http, getBaseUrl(params), data, {
+        headers,
+    });
+};
+const update = (http, params, rawData, headers) => {
+    var _a;
+    const data = copy(rawData);
+    delete data.sys;
+    return raw.put(http, getWorkflowDefinitionUrl(params), data, {
+        headers: Object.assign({ 'X-Contentful-Version': (_a = rawData.sys.version) !== null && _a !== void 0 ? _a : 0 }, headers),
+    });
+};
+const del = (http, _a, headers) => {
+    var { version } = _a, params = tslib.__rest(_a, ["version"]);
+    return raw.del(http, getWorkflowDefinitionUrl(params), {
+        headers: Object.assign({ 'X-Contentful-Version': version }, headers),
+    });
+};
+
+exports.create = create;
+exports.del = del;
+exports.get = get;
+exports.getMany = getMany;
+exports.update = update;

package/dist/cjs/adapters/REST/endpoints/workflow.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+var tslib = require('tslib');
+var copy = require('fast-copy');
+var raw = require('./raw.js');
+
+const getBaseUrl = (params) => `/spaces/${params.spaceId}/environments/${params.environmentId}/workflows`;
+const getWorkflowUrl = (params) => `${getBaseUrl(params)}/${params.workflowId}`;
+const completeWorkflowUrl = (params) => `${getWorkflowUrl(params)}/complete`;
+const getMany = (http, params, headers) => raw.get(http, getBaseUrl(params), {
+    headers,
+    params: params.query,
+});
+const get = (http, params, headers) => raw.get(http, getWorkflowUrl(params), {
+    headers,
+});
+const create = (http, params, rawData, headers) => {
+    const data = copy(rawData);
+    return raw.post(http, getBaseUrl(params), data, {
+        headers,
+    });
+};
+const update = (http, params, rawData, headers) => {
+    var _a;
+    const data = copy(rawData);
+    delete data.sys;
+    return raw.put(http, getWorkflowUrl(params), data, {
+        headers: Object.assign({ 'X-Contentful-Version': (_a = rawData.sys.version) !== null && _a !== void 0 ? _a : 0 }, headers),
+    });
+};
+const del = (http, _a, headers) => {
+    var { version } = _a, params = tslib.__rest(_a, ["version"]);
+    return raw.del(http, getWorkflowUrl(params), {
+        headers: Object.assign({ 'X-Contentful-Version': version }, headers),
+    });
+};
+const complete = (http, _a, headers) => {
+    var { version } = _a, params = tslib.__rest(_a, ["version"]);
+    return raw.put(http, completeWorkflowUrl(params), null, {
+        headers: Object.assign({ 'X-Contentful-Version': version }, headers),
+    });
+};
+
+exports.complete = complete;
+exports.create = create;
+exports.del = del;
+exports.get = get;
+exports.getMany = getMany;
+exports.update = update;

package/dist/cjs/adapters/REST/endpoints/workflows-changelog.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var raw = require('./raw.js');
+
+const getBaseUrl = (params) => `/spaces/${params.spaceId}/environments/${params.environmentId}/workflows_changelog`;
+const getMany = (http, params, headers) => raw.get(http, getBaseUrl(params), {
+    headers,
+    params: params.query,
+});
+
+exports.getMany = getMany;

package/dist/cjs/adapters/REST/make-request.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var index = require('./endpoints/index.js');
+
+const makeRequest = async ({ axiosInstance, entityType, action: actionInput, params, payload, headers, userAgent, }) => {
+    var _a;
+    // `delete` is a reserved keyword. Therefore, the methods are called `del`.
+    const action = actionInput === 'delete' ? 'del' : actionInput;
+    const endpoint = 
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    (_a = index[entityType]) === null || _a === void 0 ? void 0 : _a[action];
+    if (endpoint === undefined) {
+        throw new Error('Unknown endpoint');
+    }
+    return await endpoint(axiosInstance, params, payload, Object.assign(Object.assign({}, headers), (userAgent ? { 'X-Contentful-User-Agent': userAgent } : {})));
+};
+
+exports.makeRequest = makeRequest;

package/dist/cjs/adapters/REST/rest-adapter.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var axios = require('axios');
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var makeRequest = require('./make-request.js');
+
+/**
+ * @private
+ */
+const defaultHostParameters = {
+    defaultHostname: 'api.contentful.com',
+    defaultHostnameUpload: 'upload.contentful.com',
+};
+class RestAdapter {
+    constructor(params) {
+        if (!params.accessToken) {
+            throw new TypeError('Expected parameter accessToken');
+        }
+        const copiedParams = copy(params);
+        // httpAgent and httpsAgent cannot be copied because they can contain private fields
+        copiedParams.httpAgent = params.httpAgent;
+        copiedParams.httpsAgent = params.httpsAgent;
+        this.params = Object.assign(Object.assign({}, defaultHostParameters), copiedParams);
+        this.axiosInstance = contentfulSdkCore.createHttpClient(axios, Object.assign(Object.assign({}, this.params), { headers: Object.assign(Object.assign({ 'Content-Type': 'application/vnd.contentful.management.v1+json' }, (params.userAgent ? { 'X-Contentful-User-Agent': params.userAgent } : {})), this.params.headers) }));
+    }
+    async makeRequest(opts) {
+        return makeRequest.makeRequest(Object.assign(Object.assign({}, opts), { axiosInstance: this.axiosInstance }));
+    }
+}
+
+exports.RestAdapter = RestAdapter;

package/dist/cjs/common-types.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+exports.ScheduledActionReferenceFilters = void 0;
+(function (ScheduledActionReferenceFilters) {
+    ScheduledActionReferenceFilters["contentTypeAnnotationNotIn"] = "sys.contentType.metadata.annotations.ContentType[nin]";
+})(exports.ScheduledActionReferenceFilters || (exports.ScheduledActionReferenceFilters = {}));

package/dist/cjs/common-utils.cjs

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

package/dist/cjs/constants/editor-interface-defaults/controls-defaults.cjs

@@ -0,0 +1,161 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var types = require('./types.js');
+
+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' } },
+};
+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
+ */
+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;
+    });
+}
+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' },
+};
+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 = Object.assign(Object.assign({}, DEFAULTS_WIDGET[field]), { settings: {
+            helpText: null,
+        }, widgetNamespace: 'builtin', fieldId });
+    if (types.in_(field, DEFAULTS_SETTINGS)) {
+        defaultWidget.settings = Object.assign(Object.assign({}, defaultWidget.settings), DEFAULTS_SETTINGS[field]);
+    }
+    return defaultWidget;
+}
+/*
+ * 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.
+ */
+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);
+}
+
+exports.DEFAULTS_SETTINGS = DEFAULTS_SETTINGS;
+exports.DEFAULTS_WIDGET = DEFAULTS_WIDGET;
+exports.FIELD_TYPES = FIELD_TYPES;
+exports.default = getDefaultControlOfField;
+exports.toInternalFieldType = toInternalFieldType;

package/dist/cjs/constants/editor-interface-defaults/editors-defaults.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var types = require('./types.js');
+
+const EntryEditorWidgetTypes = {
+    DEFAULT_EDITOR: {
+        name: 'Editor',
+        id: types.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: types.WidgetNamespace.EDITOR_BUILTIN,
+    name: EntryEditorWidgetTypes.DEFAULT_EDITOR.name,
+};
+const ReferencesEntryEditor = {
+    widgetId: EntryEditorWidgetTypes.REFERENCE_TREE.id,
+    widgetNamespace: types.WidgetNamespace.EDITOR_BUILTIN,
+    name: EntryEditorWidgetTypes.REFERENCE_TREE.name,
+};
+const TagsEditor = {
+    widgetId: EntryEditorWidgetTypes.TAGS_EDITOR.id,
+    widgetNamespace: types.WidgetNamespace.EDITOR_BUILTIN,
+    name: EntryEditorWidgetTypes.TAGS_EDITOR.name,
+};
+const EntryConfiguration = [DefaultEntryEditor, ReferencesEntryEditor, TagsEditor];
+
+exports.EntryConfiguration = EntryConfiguration;
+exports.EntryEditorWidgetTypes = EntryEditorWidgetTypes;

package/dist/cjs/constants/editor-interface-defaults/index.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var sidebarDefaults = require('./sidebar-defaults.js');
+var editorsDefaults = require('./editors-defaults.js');
+var controlsDefaults = require('./controls-defaults.js');
+
+var index = {
+    SidebarEntryConfiguration: sidebarDefaults.SidebarEntryConfiguration,
+    SidebarAssetConfiguration: sidebarDefaults.SidebarAssetConfiguration,
+    EntryConfiguration: editorsDefaults.EntryConfiguration,
+    getDefaultControlOfField: controlsDefaults.default,
+};
+
+module.exports = index;