@strapi/i18n 0.0.0-experimental.c222e1c4de12dd05c26938a605a1128fb3481d1d → 0.0.0-experimental.c23f51fc41b3ef5de081f427d07e87af93cdcb2c

package/dist/server/constants/iso-locales.json.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iso-locales.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/server/content-types/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var index = require('./locale/index.js');
+
+var contentTypes = {
+    locale: index
+};
+
+module.exports = contentTypes;
+//# sourceMappingURL=index.js.map

package/dist/server/content-types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../server/src/content-types/index.ts"],"sourcesContent":["import locale from './locale';\n\nexport default {\n  locale,\n};\n"],"names":["locale"],"mappings":";;;;AAEA,mBAAe;AACbA,YAAAA;AACF,CAAE;;;;"}

package/dist/server/content-types/index.mjs

@@ -0,0 +1,8 @@
+import locale from './locale/index.mjs';
+
+var contentTypes = {
+    locale
+};
+
+export { contentTypes as default };
+//# sourceMappingURL=index.mjs.map

package/dist/server/content-types/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../server/src/content-types/index.ts"],"sourcesContent":["import locale from './locale';\n\nexport default {\n  locale,\n};\n"],"names":["locale"],"mappings":";;AAEA,mBAAe;AACbA,IAAAA;AACF,CAAE;;;;"}

package/dist/server/content-types/locale/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var schema = require('./schema.json.js');
+
+var locale = {
+    schema: schema.default
+};
+
+module.exports = locale;
+//# sourceMappingURL=index.js.map

package/dist/server/content-types/locale/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../server/src/content-types/locale/index.ts"],"sourcesContent":["import schema from './schema.json';\n\nexport default {\n  schema,\n};\n"],"names":["schema"],"mappings":";;;;AAEA,aAAe;AACbA,YAAAA;AACF,CAAE;;;;"}

package/dist/server/content-types/locale/index.mjs

@@ -0,0 +1,8 @@
+import schema from './schema.json.mjs';
+
+var locale = {
+    schema
+};
+
+export { locale as default };
+//# sourceMappingURL=index.mjs.map

package/dist/server/content-types/locale/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../../server/src/content-types/locale/index.ts"],"sourcesContent":["import schema from './schema.json';\n\nexport default {\n  schema,\n};\n"],"names":["schema"],"mappings":";;AAEA,aAAe;AACbA,IAAAA;AACF,CAAE;;;;"}

package/dist/server/content-types/locale/schema.json.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var info = {
+    singularName: "locale",
+    pluralName: "locales",
+    collectionName: "locales",
+    displayName: "Locale",
+    description: ""
+};
+var options = {};
+var pluginOptions = {
+    "content-manager": {
+        visible: false
+    },
+    "content-type-builder": {
+        visible: false
+    }
+};
+var attributes = {
+    name: {
+        type: "string",
+        min: 1,
+        max: 50,
+        configurable: false
+    },
+    code: {
+        type: "string",
+        unique: true,
+        configurable: false
+    }
+};
+var schema = {
+    info: info,
+    options: options,
+    pluginOptions: pluginOptions,
+    attributes: attributes
+};
+
+exports.attributes = attributes;
+exports.default = schema;
+exports.info = info;
+exports.options = options;
+exports.pluginOptions = pluginOptions;
+//# sourceMappingURL=schema.json.js.map

package/dist/server/content-types/locale/schema.json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/server/content-types/locale/schema.json.mjs

@@ -0,0 +1,38 @@
+var info = {
+    singularName: "locale",
+    pluralName: "locales",
+    collectionName: "locales",
+    displayName: "Locale",
+    description: ""
+};
+var options = {};
+var pluginOptions = {
+    "content-manager": {
+        visible: false
+    },
+    "content-type-builder": {
+        visible: false
+    }
+};
+var attributes = {
+    name: {
+        type: "string",
+        min: 1,
+        max: 50,
+        configurable: false
+    },
+    code: {
+        type: "string",
+        unique: true,
+        configurable: false
+    }
+};
+var schema = {
+    info: info,
+    options: options,
+    pluginOptions: pluginOptions,
+    attributes: attributes
+};
+
+export { attributes, schema as default, info, options, pluginOptions };
+//# sourceMappingURL=schema.json.mjs.map

package/dist/server/content-types/locale/schema.json.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/server/controllers/content-types.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var fp = require('lodash/fp');
+var utils = require('@strapi/utils');
+var index = require('../utils/index.js');
+var contentTypes = require('../validation/content-types.js');
+
+const { ApplicationError } = utils.errors;
+const { PUBLISHED_AT_ATTRIBUTE } = utils.contentTypes.constants;
+const getLocalesProperty = fp.getOr([], 'properties.locales');
+const getFieldsProperty = fp.prop('properties.fields');
+const getFirstLevelPath = fp.map((path)=>path.split('.')[0]);
+const controller = {
+    async getNonLocalizedAttributes (ctx) {
+        const { user } = ctx.state;
+        const body = ctx.request.body;
+        const { model, id, locale } = body;
+        await contentTypes.validateGetNonLocalizedAttributesInput({
+            model,
+            id,
+            locale
+        });
+        const { copyNonLocalizedAttributes, isLocalizedContentType, getNestedPopulateOfNonLocalizedAttributes } = index.getService('content-types');
+        const { default: { READ_ACTION, CREATE_ACTION } } = strapi.service('admin::constants');
+        const modelDef = strapi.contentType(model);
+        const attributesToPopulate = getNestedPopulateOfNonLocalizedAttributes(model);
+        if (!isLocalizedContentType(modelDef)) {
+            throw new ApplicationError(`Model ${model} is not localized`);
+        }
+        const params = modelDef.kind === 'singleType' ? {} : {
+            id
+        };
+        const entity = await strapi.db.query(model).findOne({
+            where: params,
+            populate: attributesToPopulate
+        });
+        if (!entity) {
+            return ctx.notFound();
+        }
+        const permissions = await strapi.admin.services.permission.findMany({
+            where: {
+                action: [
+                    READ_ACTION,
+                    CREATE_ACTION
+                ],
+                subject: model,
+                role: {
+                    id: user.roles.map(fp.prop('id'))
+                }
+            }
+        });
+        const localePermissions = permissions.filter((perm)=>getLocalesProperty(perm).includes(locale)).map(getFieldsProperty);
+        const permittedFields = fp.pipe(fp.flatten, getFirstLevelPath, fp.uniq)(localePermissions);
+        const nonLocalizedFields = copyNonLocalizedAttributes(modelDef, entity);
+        const sanitizedNonLocalizedFields = fp.pick(permittedFields, nonLocalizedFields);
+        const availableLocalesResult = await strapi.plugins['content-manager'].service('document-metadata').getMetadata(model, entity, {
+            availableLocales: true
+        });
+        const availableLocales = availableLocalesResult.availableLocales.map((localeResult)=>fp.pick([
+                'id',
+                'locale',
+                PUBLISHED_AT_ATTRIBUTE
+            ], localeResult));
+        ctx.body = {
+            nonLocalizedFields: sanitizedNonLocalizedFields,
+            localizations: availableLocales.concat(fp.pick([
+                'id',
+                'locale',
+                PUBLISHED_AT_ATTRIBUTE
+            ], entity))
+        };
+    }
+};
+
+module.exports = controller;
+//# sourceMappingURL=content-types.js.map

package/dist/server/controllers/content-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-types.js","sources":["../../../server/src/controllers/content-types.ts"],"sourcesContent":["import { pick, uniq, prop, getOr, flatten, pipe, map } from 'lodash/fp';\nimport { contentTypes as contentTypesUtils, errors } from '@strapi/utils';\nimport type { Core } from '@strapi/types';\nimport { getService } from '../utils';\nimport { validateGetNonLocalizedAttributesInput } from '../validation/content-types';\n\nconst { ApplicationError } = errors;\n\nconst { PUBLISHED_AT_ATTRIBUTE } = contentTypesUtils.constants;\n\nconst getLocalesProperty = getOr<string[]>([], 'properties.locales');\nconst getFieldsProperty = prop('properties.fields');\n\nconst getFirstLevelPath = map((path: string) => path.split('.')[0]);\n\nconst controller = {\n  async getNonLocalizedAttributes(ctx) {\n    const { user } = ctx.state;\n    const body = ctx.request.body as any;\n    const { model, id, locale } = body;\n\n    await validateGetNonLocalizedAttributesInput({ model, id, locale });\n\n    const {\n      copyNonLocalizedAttributes,\n      isLocalizedContentType,\n      getNestedPopulateOfNonLocalizedAttributes,\n    } = getService('content-types');\n\n    const {\n      default: { READ_ACTION, CREATE_ACTION },\n    } = strapi.service('admin::constants');\n\n    const modelDef = strapi.contentType(model);\n    const attributesToPopulate = getNestedPopulateOfNonLocalizedAttributes(model);\n\n    if (!isLocalizedContentType(modelDef)) {\n      throw new ApplicationError(`Model ${model} is not localized`);\n    }\n\n    const params = modelDef.kind === 'singleType' ? {} : { id };\n\n    const entity = await strapi.db\n      .query(model)\n      .findOne({ where: params, populate: attributesToPopulate });\n\n    if (!entity) {\n      return ctx.notFound();\n    }\n\n    const permissions = await strapi.admin.services.permission.findMany({\n      where: {\n        action: [READ_ACTION, CREATE_ACTION],\n        subject: model,\n        role: {\n          id: user.roles.map(prop('id')),\n        },\n      },\n    });\n\n    const localePermissions = permissions\n      .filter((perm: any) => getLocalesProperty(perm).includes(locale))\n      .map(getFieldsProperty);\n\n    const permittedFields = pipe(flatten, getFirstLevelPath, uniq)(localePermissions);\n\n    const nonLocalizedFields = copyNonLocalizedAttributes(modelDef, entity);\n    const sanitizedNonLocalizedFields = pick(permittedFields, nonLocalizedFields);\n\n    const availableLocalesResult = await strapi.plugins['content-manager']\n      .service('document-metadata')\n      .getMetadata(model, entity, {\n        availableLocales: true,\n      });\n\n    const availableLocales = availableLocalesResult.availableLocales.map((localeResult: any) =>\n      pick(['id', 'locale', PUBLISHED_AT_ATTRIBUTE], localeResult)\n    );\n\n    ctx.body = {\n      nonLocalizedFields: sanitizedNonLocalizedFields,\n      localizations: availableLocales.concat(\n        pick(['id', 'locale', PUBLISHED_AT_ATTRIBUTE], entity)\n      ),\n    };\n  },\n} satisfies Core.Controller;\n\nexport default controller;\n"],"names":["ApplicationError","errors","PUBLISHED_AT_ATTRIBUTE","contentTypesUtils","constants","getLocalesProperty","getOr","getFieldsProperty","prop","getFirstLevelPath","map","path","split","controller","getNonLocalizedAttributes","ctx","user","state","body","request","model","id","locale","validateGetNonLocalizedAttributesInput","copyNonLocalizedAttributes","isLocalizedContentType","getNestedPopulateOfNonLocalizedAttributes","getService","default","READ_ACTION","CREATE_ACTION","strapi","service","modelDef","contentType","attributesToPopulate","params","kind","entity","db","query","findOne","where","populate","notFound","permissions","admin","services","permission","findMany","action","subject","role","roles","localePermissions","filter","perm","includes","permittedFields","pipe","flatten","uniq","nonLocalizedFields","sanitizedNonLocalizedFields","pick","availableLocalesResult","plugins","getMetadata","availableLocales","localeResult","localizations","concat"],"mappings":"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"}

package/dist/server/controllers/content-types.mjs

@@ -0,0 +1,74 @@
+import { getOr, prop, map, pipe, flatten, uniq, pick } from 'lodash/fp';
+import { contentTypes, errors } from '@strapi/utils';
+import { getService } from '../utils/index.mjs';
+import { validateGetNonLocalizedAttributesInput } from '../validation/content-types.mjs';
+
+const { ApplicationError } = errors;
+const { PUBLISHED_AT_ATTRIBUTE } = contentTypes.constants;
+const getLocalesProperty = getOr([], 'properties.locales');
+const getFieldsProperty = prop('properties.fields');
+const getFirstLevelPath = map((path)=>path.split('.')[0]);
+const controller = {
+    async getNonLocalizedAttributes (ctx) {
+        const { user } = ctx.state;
+        const body = ctx.request.body;
+        const { model, id, locale } = body;
+        await validateGetNonLocalizedAttributesInput({
+            model,
+            id,
+            locale
+        });
+        const { copyNonLocalizedAttributes, isLocalizedContentType, getNestedPopulateOfNonLocalizedAttributes } = getService('content-types');
+        const { default: { READ_ACTION, CREATE_ACTION } } = strapi.service('admin::constants');
+        const modelDef = strapi.contentType(model);
+        const attributesToPopulate = getNestedPopulateOfNonLocalizedAttributes(model);
+        if (!isLocalizedContentType(modelDef)) {
+            throw new ApplicationError(`Model ${model} is not localized`);
+        }
+        const params = modelDef.kind === 'singleType' ? {} : {
+            id
+        };
+        const entity = await strapi.db.query(model).findOne({
+            where: params,
+            populate: attributesToPopulate
+        });
+        if (!entity) {
+            return ctx.notFound();
+        }
+        const permissions = await strapi.admin.services.permission.findMany({
+            where: {
+                action: [
+                    READ_ACTION,
+                    CREATE_ACTION
+                ],
+                subject: model,
+                role: {
+                    id: user.roles.map(prop('id'))
+                }
+            }
+        });
+        const localePermissions = permissions.filter((perm)=>getLocalesProperty(perm).includes(locale)).map(getFieldsProperty);
+        const permittedFields = pipe(flatten, getFirstLevelPath, uniq)(localePermissions);
+        const nonLocalizedFields = copyNonLocalizedAttributes(modelDef, entity);
+        const sanitizedNonLocalizedFields = pick(permittedFields, nonLocalizedFields);
+        const availableLocalesResult = await strapi.plugins['content-manager'].service('document-metadata').getMetadata(model, entity, {
+            availableLocales: true
+        });
+        const availableLocales = availableLocalesResult.availableLocales.map((localeResult)=>pick([
+                'id',
+                'locale',
+                PUBLISHED_AT_ATTRIBUTE
+            ], localeResult));
+        ctx.body = {
+            nonLocalizedFields: sanitizedNonLocalizedFields,
+            localizations: availableLocales.concat(pick([
+                'id',
+                'locale',
+                PUBLISHED_AT_ATTRIBUTE
+            ], entity))
+        };
+    }
+};
+
+export { controller as default };
+//# sourceMappingURL=content-types.mjs.map

package/dist/server/controllers/content-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-types.mjs","sources":["../../../server/src/controllers/content-types.ts"],"sourcesContent":["import { pick, uniq, prop, getOr, flatten, pipe, map } from 'lodash/fp';\nimport { contentTypes as contentTypesUtils, errors } from '@strapi/utils';\nimport type { Core } from '@strapi/types';\nimport { getService } from '../utils';\nimport { validateGetNonLocalizedAttributesInput } from '../validation/content-types';\n\nconst { ApplicationError } = errors;\n\nconst { PUBLISHED_AT_ATTRIBUTE } = contentTypesUtils.constants;\n\nconst getLocalesProperty = getOr<string[]>([], 'properties.locales');\nconst getFieldsProperty = prop('properties.fields');\n\nconst getFirstLevelPath = map((path: string) => path.split('.')[0]);\n\nconst controller = {\n  async getNonLocalizedAttributes(ctx) {\n    const { user } = ctx.state;\n    const body = ctx.request.body as any;\n    const { model, id, locale } = body;\n\n    await validateGetNonLocalizedAttributesInput({ model, id, locale });\n\n    const {\n      copyNonLocalizedAttributes,\n      isLocalizedContentType,\n      getNestedPopulateOfNonLocalizedAttributes,\n    } = getService('content-types');\n\n    const {\n      default: { READ_ACTION, CREATE_ACTION },\n    } = strapi.service('admin::constants');\n\n    const modelDef = strapi.contentType(model);\n    const attributesToPopulate = getNestedPopulateOfNonLocalizedAttributes(model);\n\n    if (!isLocalizedContentType(modelDef)) {\n      throw new ApplicationError(`Model ${model} is not localized`);\n    }\n\n    const params = modelDef.kind === 'singleType' ? {} : { id };\n\n    const entity = await strapi.db\n      .query(model)\n      .findOne({ where: params, populate: attributesToPopulate });\n\n    if (!entity) {\n      return ctx.notFound();\n    }\n\n    const permissions = await strapi.admin.services.permission.findMany({\n      where: {\n        action: [READ_ACTION, CREATE_ACTION],\n        subject: model,\n        role: {\n          id: user.roles.map(prop('id')),\n        },\n      },\n    });\n\n    const localePermissions = permissions\n      .filter((perm: any) => getLocalesProperty(perm).includes(locale))\n      .map(getFieldsProperty);\n\n    const permittedFields = pipe(flatten, getFirstLevelPath, uniq)(localePermissions);\n\n    const nonLocalizedFields = copyNonLocalizedAttributes(modelDef, entity);\n    const sanitizedNonLocalizedFields = pick(permittedFields, nonLocalizedFields);\n\n    const availableLocalesResult = await strapi.plugins['content-manager']\n      .service('document-metadata')\n      .getMetadata(model, entity, {\n        availableLocales: true,\n      });\n\n    const availableLocales = availableLocalesResult.availableLocales.map((localeResult: any) =>\n      pick(['id', 'locale', PUBLISHED_AT_ATTRIBUTE], localeResult)\n    );\n\n    ctx.body = {\n      nonLocalizedFields: sanitizedNonLocalizedFields,\n      localizations: availableLocales.concat(\n        pick(['id', 'locale', PUBLISHED_AT_ATTRIBUTE], entity)\n      ),\n    };\n  },\n} satisfies Core.Controller;\n\nexport default controller;\n"],"names":["ApplicationError","errors","PUBLISHED_AT_ATTRIBUTE","contentTypesUtils","constants","getLocalesProperty","getOr","getFieldsProperty","prop","getFirstLevelPath","map","path","split","controller","getNonLocalizedAttributes","ctx","user","state","body","request","model","id","locale","validateGetNonLocalizedAttributesInput","copyNonLocalizedAttributes","isLocalizedContentType","getNestedPopulateOfNonLocalizedAttributes","getService","default","READ_ACTION","CREATE_ACTION","strapi","service","modelDef","contentType","attributesToPopulate","params","kind","entity","db","query","findOne","where","populate","notFound","permissions","admin","services","permission","findMany","action","subject","role","roles","localePermissions","filter","perm","includes","permittedFields","pipe","flatten","uniq","nonLocalizedFields","sanitizedNonLocalizedFields","pick","availableLocalesResult","plugins","getMetadata","availableLocales","localeResult","localizations","concat"],"mappings":"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"}

package/dist/server/controllers/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var locales = require('./locales.js');
+var contentTypes = require('./content-types.js');
+var isoLocales = require('./iso-locales.js');
+
+var controllers = {
+    locales,
+    'iso-locales': isoLocales,
+    'content-types': contentTypes
+};
+
+module.exports = controllers;
+//# sourceMappingURL=index.js.map

package/dist/server/controllers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../server/src/controllers/index.ts"],"sourcesContent":["import locales from './locales';\nimport contentTypes from './content-types';\nimport isoLocales from './iso-locales';\n\nexport default {\n  locales,\n  'iso-locales': isoLocales,\n  'content-types': contentTypes,\n};\n"],"names":["locales","isoLocales","contentTypes"],"mappings":";;;;;;AAIA,kBAAe;AACbA,IAAAA,OAAAA;IACA,aAAeC,EAAAA,UAAAA;IACf,eAAiBC,EAAAA;AACnB,CAAE;;;;"}

package/dist/server/controllers/index.mjs

@@ -0,0 +1,12 @@
+import controller from './locales.mjs';
+import controller$2 from './content-types.mjs';
+import controller$1 from './iso-locales.mjs';
+
+var controllers = {
+    locales: controller,
+    'iso-locales': controller$1,
+    'content-types': controller$2
+};
+
+export { controllers as default };
+//# sourceMappingURL=index.mjs.map

package/dist/server/controllers/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../server/src/controllers/index.ts"],"sourcesContent":["import locales from './locales';\nimport contentTypes from './content-types';\nimport isoLocales from './iso-locales';\n\nexport default {\n  locales,\n  'iso-locales': isoLocales,\n  'content-types': contentTypes,\n};\n"],"names":["locales","isoLocales","contentTypes"],"mappings":";;;;AAIA,kBAAe;AACbA,aAAAA,UAAAA;IACA,aAAeC,EAAAA,YAAAA;IACf,eAAiBC,EAAAA;AACnB,CAAE;;;;"}

package/dist/server/controllers/iso-locales.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var index = require('../utils/index.js');
+
+const controller = {
+    listIsoLocales (ctx) {
+        const isoLocalesService = index.getService('iso-locales');
+        ctx.body = isoLocalesService.getIsoLocales();
+    }
+};
+
+module.exports = controller;
+//# sourceMappingURL=iso-locales.js.map

package/dist/server/controllers/iso-locales.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iso-locales.js","sources":["../../../server/src/controllers/iso-locales.ts"],"sourcesContent":["import type { Core } from '@strapi/types';\nimport { getService } from '../utils';\n\nconst controller: Core.Controller = {\n  listIsoLocales(ctx) {\n    const isoLocalesService = getService('iso-locales');\n\n    ctx.body = isoLocalesService.getIsoLocales();\n  },\n};\n\nexport default controller;\n"],"names":["controller","listIsoLocales","ctx","isoLocalesService","getService","body","getIsoLocales"],"mappings":";;;;AAGA,MAAMA,UAA8B,GAAA;AAClCC,IAAAA,cAAAA,CAAAA,CAAeC,GAAG,EAAA;AAChB,QAAA,MAAMC,oBAAoBC,gBAAW,CAAA,aAAA,CAAA;QAErCF,GAAIG,CAAAA,IAAI,GAAGF,iBAAAA,CAAkBG,aAAa,EAAA;AAC5C;AACF;;;;"}

package/dist/server/controllers/iso-locales.mjs

@@ -0,0 +1,11 @@
+import { getService } from '../utils/index.mjs';
+
+const controller = {
+    listIsoLocales (ctx) {
+        const isoLocalesService = getService('iso-locales');
+        ctx.body = isoLocalesService.getIsoLocales();
+    }
+};
+
+export { controller as default };
+//# sourceMappingURL=iso-locales.mjs.map

package/dist/server/controllers/iso-locales.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iso-locales.mjs","sources":["../../../server/src/controllers/iso-locales.ts"],"sourcesContent":["import type { Core } from '@strapi/types';\nimport { getService } from '../utils';\n\nconst controller: Core.Controller = {\n  listIsoLocales(ctx) {\n    const isoLocalesService = getService('iso-locales');\n\n    ctx.body = isoLocalesService.getIsoLocales();\n  },\n};\n\nexport default controller;\n"],"names":["controller","listIsoLocales","ctx","isoLocalesService","getService","body","getIsoLocales"],"mappings":";;AAGA,MAAMA,UAA8B,GAAA;AAClCC,IAAAA,cAAAA,CAAAA,CAAeC,GAAG,EAAA;AAChB,QAAA,MAAMC,oBAAoBC,UAAW,CAAA,aAAA,CAAA;QAErCF,GAAIG,CAAAA,IAAI,GAAGF,iBAAAA,CAAkBG,aAAa,EAAA;AAC5C;AACF;;;;"}

package/dist/server/controllers/locales.js

@@ -0,0 +1,108 @@
+'use strict';
+
+var utils = require('@strapi/utils');
+var fp = require('lodash/fp');
+var index = require('../utils/index.js');
+var locales = require('../validation/locales.js');
+var locale = require('../domain/locale.js');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var utils__namespace = /*#__PURE__*/_interopNamespaceDefault(utils);
+
+const { setCreatorFields } = utils__namespace;
+const { ApplicationError } = utils__namespace.errors;
+const sanitizeLocale = (locale)=>{
+    const model = strapi.getModel('plugin::i18n.locale');
+    return strapi.contentAPI.sanitize.output(locale, model);
+};
+const controller = {
+    async listLocales (ctx) {
+        const localesService = index.getService('locales');
+        const locales = await localesService.find();
+        const sanitizedLocales = await sanitizeLocale(locales);
+        ctx.body = await localesService.setIsDefault(sanitizedLocales);
+    },
+    async createLocale (ctx) {
+        const { user } = ctx.state;
+        const body = ctx.request.body;
+        const { isDefault, ...localeToCreate } = body;
+        await locales.validateCreateLocaleInput(body);
+        const localesService = index.getService('locales');
+        const existingLocale = await localesService.findByCode(body.code);
+        if (existingLocale) {
+            throw new ApplicationError('This locale already exists');
+        }
+        const localeToPersist = setCreatorFields({
+            user
+        })(locale.formatLocale(localeToCreate));
+        const locale$1 = await localesService.create(localeToPersist);
+        if (isDefault) {
+            await localesService.setDefaultLocale(locale$1);
+        }
+        const sanitizedLocale = await sanitizeLocale(locale$1);
+        ctx.body = await localesService.setIsDefault(sanitizedLocale);
+    },
+    async updateLocale (ctx) {
+        const { user } = ctx.state;
+        const { id } = ctx.params;
+        const body = ctx.request.body;
+        const { isDefault, ...updates } = body;
+        await locales.validateUpdateLocaleInput(body);
+        const localesService = index.getService('locales');
+        const existingLocale = await localesService.findById(id);
+        if (!existingLocale) {
+            return ctx.notFound('locale.notFound');
+        }
+        const allowedParams = [
+            'name'
+        ];
+        const cleanUpdates = setCreatorFields({
+            user,
+            isEdition: true
+        })(fp.pick(allowedParams, updates));
+        const updatedLocale = await localesService.update({
+            id
+        }, cleanUpdates);
+        if (isDefault) {
+            await localesService.setDefaultLocale(updatedLocale);
+        }
+        const sanitizedLocale = await sanitizeLocale(updatedLocale);
+        ctx.body = await localesService.setIsDefault(sanitizedLocale);
+    },
+    async deleteLocale (ctx) {
+        const { id } = ctx.params;
+        const localesService = index.getService('locales');
+        const existingLocale = await localesService.findById(id);
+        if (!existingLocale) {
+            return ctx.notFound('locale.notFound');
+        }
+        const defaultLocaleCode = await localesService.getDefaultLocale();
+        if (existingLocale.code === defaultLocaleCode) {
+            throw new ApplicationError('Cannot delete the default locale');
+        }
+        await localesService.delete({
+            id
+        });
+        const sanitizedLocale = await sanitizeLocale(existingLocale);
+        ctx.body = await localesService.setIsDefault(sanitizedLocale);
+    }
+};
+
+module.exports = controller;
+//# sourceMappingURL=locales.js.map

package/dist/server/controllers/locales.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locales.js","sources":["../../../server/src/controllers/locales.ts"],"sourcesContent":["import * as utils from '@strapi/utils';\nimport { pick } from 'lodash/fp';\nimport type { Core } from '@strapi/types';\nimport { getService } from '../utils';\nimport { validateCreateLocaleInput, validateUpdateLocaleInput } from '../validation/locales';\nimport { formatLocale } from '../domain/locale';\n\nconst { setCreatorFields } = utils;\nconst { ApplicationError } = utils.errors;\n\nconst sanitizeLocale = (locale: any) => {\n  const model = strapi.getModel('plugin::i18n.locale');\n\n  return strapi.contentAPI.sanitize.output(locale, model);\n};\n\nconst controller: Core.Controller = {\n  async listLocales(ctx) {\n    const localesService = getService('locales');\n\n    const locales = await localesService.find();\n    const sanitizedLocales = await sanitizeLocale(locales);\n\n    ctx.body = await localesService.setIsDefault(sanitizedLocales);\n  },\n\n  async createLocale(ctx) {\n    const { user } = ctx.state;\n    const body = ctx.request.body as any;\n    const { isDefault, ...localeToCreate } = body;\n\n    await validateCreateLocaleInput(body);\n\n    const localesService = getService('locales');\n\n    const existingLocale = await localesService.findByCode(body.code);\n    if (existingLocale) {\n      throw new ApplicationError('This locale already exists');\n    }\n\n    const localeToPersist = setCreatorFields({ user })(formatLocale(localeToCreate));\n\n    const locale = await localesService.create(localeToPersist);\n\n    if (isDefault) {\n      await localesService.setDefaultLocale(locale);\n    }\n\n    const sanitizedLocale = await sanitizeLocale(locale);\n\n    ctx.body = await localesService.setIsDefault(sanitizedLocale);\n  },\n\n  async updateLocale(ctx) {\n    const { user } = ctx.state;\n    const { id } = ctx.params;\n    const body = ctx.request.body as any;\n    const { isDefault, ...updates } = body;\n\n    await validateUpdateLocaleInput(body);\n\n    const localesService = getService('locales');\n\n    const existingLocale = await localesService.findById(id);\n    if (!existingLocale) {\n      return ctx.notFound('locale.notFound');\n    }\n\n    const allowedParams = ['name'];\n    const cleanUpdates = setCreatorFields({ user, isEdition: true })(pick(allowedParams, updates));\n\n    const updatedLocale = await localesService.update({ id }, cleanUpdates);\n\n    if (isDefault) {\n      await localesService.setDefaultLocale(updatedLocale);\n    }\n\n    const sanitizedLocale = await sanitizeLocale(updatedLocale);\n\n    ctx.body = await localesService.setIsDefault(sanitizedLocale);\n  },\n\n  async deleteLocale(ctx) {\n    const { id } = ctx.params;\n\n    const localesService = getService('locales');\n\n    const existingLocale = await localesService.findById(id);\n    if (!existingLocale) {\n      return ctx.notFound('locale.notFound');\n    }\n\n    const defaultLocaleCode = await localesService.getDefaultLocale();\n    if (existingLocale.code === defaultLocaleCode) {\n      throw new ApplicationError('Cannot delete the default locale');\n    }\n\n    await localesService.delete({ id });\n\n    const sanitizedLocale = await sanitizeLocale(existingLocale);\n\n    ctx.body = await localesService.setIsDefault(sanitizedLocale);\n  },\n};\n\nexport default controller;\n"],"names":["setCreatorFields","utils","ApplicationError","errors","sanitizeLocale","locale","model","strapi","getModel","contentAPI","sanitize","output","controller","listLocales","ctx","localesService","getService","locales","find","sanitizedLocales","body","setIsDefault","createLocale","user","state","request","isDefault","localeToCreate","validateCreateLocaleInput","existingLocale","findByCode","code","localeToPersist","formatLocale","create","setDefaultLocale","sanitizedLocale","updateLocale","id","params","updates","validateUpdateLocaleInput","findById","notFound","allowedParams","cleanUpdates","isEdition","pick","updatedLocale","update","deleteLocale","defaultLocaleCode","getDefaultLocale","delete"],"mappings":"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"}

package/dist/server/controllers/locales.mjs

@@ -0,0 +1,87 @@
+import * as utils from '@strapi/utils';
+import { pick } from 'lodash/fp';
+import { getService } from '../utils/index.mjs';
+import { validateCreateLocaleInput, validateUpdateLocaleInput } from '../validation/locales.mjs';
+import { formatLocale } from '../domain/locale.mjs';
+
+const { setCreatorFields } = utils;
+const { ApplicationError } = utils.errors;
+const sanitizeLocale = (locale)=>{
+    const model = strapi.getModel('plugin::i18n.locale');
+    return strapi.contentAPI.sanitize.output(locale, model);
+};
+const controller = {
+    async listLocales (ctx) {
+        const localesService = getService('locales');
+        const locales = await localesService.find();
+        const sanitizedLocales = await sanitizeLocale(locales);
+        ctx.body = await localesService.setIsDefault(sanitizedLocales);
+    },
+    async createLocale (ctx) {
+        const { user } = ctx.state;
+        const body = ctx.request.body;
+        const { isDefault, ...localeToCreate } = body;
+        await validateCreateLocaleInput(body);
+        const localesService = getService('locales');
+        const existingLocale = await localesService.findByCode(body.code);
+        if (existingLocale) {
+            throw new ApplicationError('This locale already exists');
+        }
+        const localeToPersist = setCreatorFields({
+            user
+        })(formatLocale(localeToCreate));
+        const locale = await localesService.create(localeToPersist);
+        if (isDefault) {
+            await localesService.setDefaultLocale(locale);
+        }
+        const sanitizedLocale = await sanitizeLocale(locale);
+        ctx.body = await localesService.setIsDefault(sanitizedLocale);
+    },
+    async updateLocale (ctx) {
+        const { user } = ctx.state;
+        const { id } = ctx.params;
+        const body = ctx.request.body;
+        const { isDefault, ...updates } = body;
+        await validateUpdateLocaleInput(body);
+        const localesService = getService('locales');
+        const existingLocale = await localesService.findById(id);
+        if (!existingLocale) {
+            return ctx.notFound('locale.notFound');
+        }
+        const allowedParams = [
+            'name'
+        ];
+        const cleanUpdates = setCreatorFields({
+            user,
+            isEdition: true
+        })(pick(allowedParams, updates));
+        const updatedLocale = await localesService.update({
+            id
+        }, cleanUpdates);
+        if (isDefault) {
+            await localesService.setDefaultLocale(updatedLocale);
+        }
+        const sanitizedLocale = await sanitizeLocale(updatedLocale);
+        ctx.body = await localesService.setIsDefault(sanitizedLocale);
+    },
+    async deleteLocale (ctx) {
+        const { id } = ctx.params;
+        const localesService = getService('locales');
+        const existingLocale = await localesService.findById(id);
+        if (!existingLocale) {
+            return ctx.notFound('locale.notFound');
+        }
+        const defaultLocaleCode = await localesService.getDefaultLocale();
+        if (existingLocale.code === defaultLocaleCode) {
+            throw new ApplicationError('Cannot delete the default locale');
+        }
+        await localesService.delete({
+            id
+        });
+        const sanitizedLocale = await sanitizeLocale(existingLocale);
+        ctx.body = await localesService.setIsDefault(sanitizedLocale);
+    }
+};
+
+export { controller as default };
+//# sourceMappingURL=locales.mjs.map