@strapi/i18n 0.0.0-next.926e9af9369b89a571145e3c8fa1ce6bfd6cc0ab → 0.0.0-next.92e60e369ae0e382a5d486de347f6d286ab22987

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/ai-localization-jobs.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const createAILocalizationJobsController = ({ strapi })=>{
+    const getService = (name)=>strapi.plugin('i18n').service(name);
+    const aiLocalizationJobsService = getService('ai-localization-jobs');
+    return {
+        /**
+     * Get a job for a singleType using the contentType
+     * There is only 1 job per contentType
+     */ async getJobForSingleType (ctx) {
+            const { contentType } = ctx.params;
+            if (!contentType) {
+                return ctx.badRequest('contentType is required');
+            }
+            try {
+                const job = await aiLocalizationJobsService.getJobByContentType(contentType);
+                ctx.body = {
+                    data: job
+                };
+            } catch (error) {
+                strapi.log.error('[AI Localizations Jobs] Error fetching job:', error);
+                ctx.internalServerError('Failed to fetch AI localizations job');
+            }
+        },
+        /**
+     * Get a job for a collectionType using the documentId
+     * There is only 1 job per documentId
+     */ async getJobForCollectionType (ctx) {
+            const { documentId, contentType } = ctx.params;
+            if (!documentId || !contentType) {
+                return ctx.badRequest('Document ID and contentType are required');
+            }
+            try {
+                const job = await aiLocalizationJobsService.getJobByDocument(contentType, documentId);
+                ctx.body = {
+                    data: job
+                };
+            } catch (error) {
+                strapi.log.error('[AI Localizations Jobs] Error fetching job:', error);
+                ctx.internalServerError('Failed to fetch AI localizations job');
+            }
+        }
+    };
+};
+
+module.exports = createAILocalizationJobsController;
+//# sourceMappingURL=ai-localization-jobs.js.map

package/dist/server/controllers/ai-localization-jobs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-localization-jobs.js","sources":["../../../server/src/controllers/ai-localization-jobs.ts"],"sourcesContent":["import type { Core } from '@strapi/types';\n\nconst createAILocalizationJobsController = ({ strapi }: { strapi: Core.Strapi }) => {\n  const getService = (name: string) => strapi.plugin('i18n').service(name);\n  const aiLocalizationJobsService = getService('ai-localization-jobs');\n\n  return {\n    /**\n     * Get a job for a singleType using the contentType\n     * There is only 1 job per contentType\n     */\n    async getJobForSingleType(ctx: any) {\n      const { contentType } = ctx.params;\n\n      if (!contentType) {\n        return ctx.badRequest('contentType is required');\n      }\n\n      try {\n        const job = await aiLocalizationJobsService.getJobByContentType(contentType);\n\n        ctx.body = {\n          data: job,\n        };\n      } catch (error) {\n        strapi.log.error('[AI Localizations Jobs] Error fetching job:', error);\n        ctx.internalServerError('Failed to fetch AI localizations job');\n      }\n    },\n    /**\n     * Get a job for a collectionType using the documentId\n     * There is only 1 job per documentId\n     */\n    async getJobForCollectionType(ctx: any) {\n      const { documentId, contentType } = ctx.params;\n\n      if (!documentId || !contentType) {\n        return ctx.badRequest('Document ID and contentType are required');\n      }\n\n      try {\n        const job = await aiLocalizationJobsService.getJobByDocument(contentType, documentId);\n\n        ctx.body = {\n          data: job,\n        };\n      } catch (error) {\n        strapi.log.error('[AI Localizations Jobs] Error fetching job:', error);\n        ctx.internalServerError('Failed to fetch AI localizations job');\n      }\n    },\n  };\n};\n\nexport default createAILocalizationJobsController;\n"],"names":["createAILocalizationJobsController","strapi","getService","name","plugin","service","aiLocalizationJobsService","getJobForSingleType","ctx","contentType","params","badRequest","job","getJobByContentType","body","data","error","log","internalServerError","getJobForCollectionType","documentId","getJobByDocument"],"mappings":";;AAEA,MAAMA,kCAAqC,GAAA,CAAC,EAAEC,MAAM,EAA2B,GAAA;IAC7E,MAAMC,UAAAA,GAAa,CAACC,IAAiBF,GAAAA,MAAAA,CAAOG,MAAM,CAAC,MAAA,CAAA,CAAQC,OAAO,CAACF,IAAAA,CAAAA;AACnE,IAAA,MAAMG,4BAA4BJ,UAAW,CAAA,sBAAA,CAAA;IAE7C,OAAO;AACL;;;QAIA,MAAMK,qBAAoBC,GAAQ,EAAA;AAChC,YAAA,MAAM,EAAEC,WAAW,EAAE,GAAGD,IAAIE,MAAM;AAElC,YAAA,IAAI,CAACD,WAAa,EAAA;gBAChB,OAAOD,GAAAA,CAAIG,UAAU,CAAC,yBAAA,CAAA;AACxB;YAEA,IAAI;AACF,gBAAA,MAAMC,GAAM,GAAA,MAAMN,yBAA0BO,CAAAA,mBAAmB,CAACJ,WAAAA,CAAAA;AAEhED,gBAAAA,GAAAA,CAAIM,IAAI,GAAG;oBACTC,IAAMH,EAAAA;AACR,iBAAA;AACF,aAAA,CAAE,OAAOI,KAAO,EAAA;AACdf,gBAAAA,MAAAA,CAAOgB,GAAG,CAACD,KAAK,CAAC,6CAA+CA,EAAAA,KAAAA,CAAAA;AAChER,gBAAAA,GAAAA,CAAIU,mBAAmB,CAAC,sCAAA,CAAA;AAC1B;AACF,SAAA;AACA;;;QAIA,MAAMC,yBAAwBX,GAAQ,EAAA;AACpC,YAAA,MAAM,EAAEY,UAAU,EAAEX,WAAW,EAAE,GAAGD,IAAIE,MAAM;YAE9C,IAAI,CAACU,UAAc,IAAA,CAACX,WAAa,EAAA;gBAC/B,OAAOD,GAAAA,CAAIG,UAAU,CAAC,0CAAA,CAAA;AACxB;YAEA,IAAI;AACF,gBAAA,MAAMC,GAAM,GAAA,MAAMN,yBAA0Be,CAAAA,gBAAgB,CAACZ,WAAaW,EAAAA,UAAAA,CAAAA;AAE1EZ,gBAAAA,GAAAA,CAAIM,IAAI,GAAG;oBACTC,IAAMH,EAAAA;AACR,iBAAA;AACF,aAAA,CAAE,OAAOI,KAAO,EAAA;AACdf,gBAAAA,MAAAA,CAAOgB,GAAG,CAACD,KAAK,CAAC,6CAA+CA,EAAAA,KAAAA,CAAAA;AAChER,gBAAAA,GAAAA,CAAIU,mBAAmB,CAAC,sCAAA,CAAA;AAC1B;AACF;AACF,KAAA;AACF;;;;"}

package/dist/server/controllers/ai-localization-jobs.mjs

@@ -0,0 +1,45 @@
+const createAILocalizationJobsController = ({ strapi })=>{
+    const getService = (name)=>strapi.plugin('i18n').service(name);
+    const aiLocalizationJobsService = getService('ai-localization-jobs');
+    return {
+        /**
+     * Get a job for a singleType using the contentType
+     * There is only 1 job per contentType
+     */ async getJobForSingleType (ctx) {
+            const { contentType } = ctx.params;
+            if (!contentType) {
+                return ctx.badRequest('contentType is required');
+            }
+            try {
+                const job = await aiLocalizationJobsService.getJobByContentType(contentType);
+                ctx.body = {
+                    data: job
+                };
+            } catch (error) {
+                strapi.log.error('[AI Localizations Jobs] Error fetching job:', error);
+                ctx.internalServerError('Failed to fetch AI localizations job');
+            }
+        },
+        /**
+     * Get a job for a collectionType using the documentId
+     * There is only 1 job per documentId
+     */ async getJobForCollectionType (ctx) {
+            const { documentId, contentType } = ctx.params;
+            if (!documentId || !contentType) {
+                return ctx.badRequest('Document ID and contentType are required');
+            }
+            try {
+                const job = await aiLocalizationJobsService.getJobByDocument(contentType, documentId);
+                ctx.body = {
+                    data: job
+                };
+            } catch (error) {
+                strapi.log.error('[AI Localizations Jobs] Error fetching job:', error);
+                ctx.internalServerError('Failed to fetch AI localizations job');
+            }
+        }
+    };
+};
+
+export { createAILocalizationJobsController as default };
+//# sourceMappingURL=ai-localization-jobs.mjs.map

package/dist/server/controllers/ai-localization-jobs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-localization-jobs.mjs","sources":["../../../server/src/controllers/ai-localization-jobs.ts"],"sourcesContent":["import type { Core } from '@strapi/types';\n\nconst createAILocalizationJobsController = ({ strapi }: { strapi: Core.Strapi }) => {\n  const getService = (name: string) => strapi.plugin('i18n').service(name);\n  const aiLocalizationJobsService = getService('ai-localization-jobs');\n\n  return {\n    /**\n     * Get a job for a singleType using the contentType\n     * There is only 1 job per contentType\n     */\n    async getJobForSingleType(ctx: any) {\n      const { contentType } = ctx.params;\n\n      if (!contentType) {\n        return ctx.badRequest('contentType is required');\n      }\n\n      try {\n        const job = await aiLocalizationJobsService.getJobByContentType(contentType);\n\n        ctx.body = {\n          data: job,\n        };\n      } catch (error) {\n        strapi.log.error('[AI Localizations Jobs] Error fetching job:', error);\n        ctx.internalServerError('Failed to fetch AI localizations job');\n      }\n    },\n    /**\n     * Get a job for a collectionType using the documentId\n     * There is only 1 job per documentId\n     */\n    async getJobForCollectionType(ctx: any) {\n      const { documentId, contentType } = ctx.params;\n\n      if (!documentId || !contentType) {\n        return ctx.badRequest('Document ID and contentType are required');\n      }\n\n      try {\n        const job = await aiLocalizationJobsService.getJobByDocument(contentType, documentId);\n\n        ctx.body = {\n          data: job,\n        };\n      } catch (error) {\n        strapi.log.error('[AI Localizations Jobs] Error fetching job:', error);\n        ctx.internalServerError('Failed to fetch AI localizations job');\n      }\n    },\n  };\n};\n\nexport default createAILocalizationJobsController;\n"],"names":["createAILocalizationJobsController","strapi","getService","name","plugin","service","aiLocalizationJobsService","getJobForSingleType","ctx","contentType","params","badRequest","job","getJobByContentType","body","data","error","log","internalServerError","getJobForCollectionType","documentId","getJobByDocument"],"mappings":"AAEA,MAAMA,kCAAqC,GAAA,CAAC,EAAEC,MAAM,EAA2B,GAAA;IAC7E,MAAMC,UAAAA,GAAa,CAACC,IAAiBF,GAAAA,MAAAA,CAAOG,MAAM,CAAC,MAAA,CAAA,CAAQC,OAAO,CAACF,IAAAA,CAAAA;AACnE,IAAA,MAAMG,4BAA4BJ,UAAW,CAAA,sBAAA,CAAA;IAE7C,OAAO;AACL;;;QAIA,MAAMK,qBAAoBC,GAAQ,EAAA;AAChC,YAAA,MAAM,EAAEC,WAAW,EAAE,GAAGD,IAAIE,MAAM;AAElC,YAAA,IAAI,CAACD,WAAa,EAAA;gBAChB,OAAOD,GAAAA,CAAIG,UAAU,CAAC,yBAAA,CAAA;AACxB;YAEA,IAAI;AACF,gBAAA,MAAMC,GAAM,GAAA,MAAMN,yBAA0BO,CAAAA,mBAAmB,CAACJ,WAAAA,CAAAA;AAEhED,gBAAAA,GAAAA,CAAIM,IAAI,GAAG;oBACTC,IAAMH,EAAAA;AACR,iBAAA;AACF,aAAA,CAAE,OAAOI,KAAO,EAAA;AACdf,gBAAAA,MAAAA,CAAOgB,GAAG,CAACD,KAAK,CAAC,6CAA+CA,EAAAA,KAAAA,CAAAA;AAChER,gBAAAA,GAAAA,CAAIU,mBAAmB,CAAC,sCAAA,CAAA;AAC1B;AACF,SAAA;AACA;;;QAIA,MAAMC,yBAAwBX,GAAQ,EAAA;AACpC,YAAA,MAAM,EAAEY,UAAU,EAAEX,WAAW,EAAE,GAAGD,IAAIE,MAAM;YAE9C,IAAI,CAACU,UAAc,IAAA,CAACX,WAAa,EAAA;gBAC/B,OAAOD,GAAAA,CAAIG,UAAU,CAAC,0CAAA,CAAA;AACxB;YAEA,IAAI;AACF,gBAAA,MAAMC,GAAM,GAAA,MAAMN,yBAA0Be,CAAAA,gBAAgB,CAACZ,WAAaW,EAAAA,UAAAA,CAAAA;AAE1EZ,gBAAAA,GAAAA,CAAIM,IAAI,GAAG;oBACTC,IAAMH,EAAAA;AACR,iBAAA;AACF,aAAA,CAAE,OAAOI,KAAO,EAAA;AACdf,gBAAAA,MAAAA,CAAOgB,GAAG,CAACD,KAAK,CAAC,6CAA+CA,EAAAA,KAAAA,CAAAA;AAChER,gBAAAA,GAAAA,CAAIU,mBAAmB,CAAC,sCAAA,CAAA;AAC1B;AACF;AACF,KAAA;AACF;;;;"}

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,18 @@
+'use strict';
+
+var locales = require('./locales.js');
+var contentTypes = require('./content-types.js');
+var isoLocales = require('./iso-locales.js');
+var settings = require('./settings.js');
+var aiLocalizationJobs = require('./ai-localization-jobs.js');
+
+var controllers = {
+    locales,
+    'iso-locales': isoLocales,
+    'content-types': contentTypes,
+    settings,
+    'ai-localization-jobs': aiLocalizationJobs
+};
+
+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';\nimport settings from './settings';\nimport aiLocalizationJobs from './ai-localization-jobs';\n\nexport default {\n  locales,\n  'iso-locales': isoLocales,\n  'content-types': contentTypes,\n  settings,\n  'ai-localization-jobs': aiLocalizationJobs,\n};\n"],"names":["locales","isoLocales","contentTypes","settings","aiLocalizationJobs"],"mappings":";;;;;;;;AAMA,kBAAe;AACbA,IAAAA,OAAAA;IACA,aAAeC,EAAAA,UAAAA;IACf,eAAiBC,EAAAA,YAAAA;AACjBC,IAAAA,QAAAA;IACA,sBAAwBC,EAAAA;AAC1B,CAAE;;;;"}

package/dist/server/controllers/index.mjs

@@ -0,0 +1,16 @@
+import controller from './locales.mjs';
+import controller$2 from './content-types.mjs';
+import controller$1 from './iso-locales.mjs';
+import settings from './settings.mjs';
+import createAILocalizationJobsController from './ai-localization-jobs.mjs';
+
+var controllers = {
+    locales: controller,
+    'iso-locales': controller$1,
+    'content-types': controller$2,
+    settings,
+    'ai-localization-jobs': createAILocalizationJobsController
+};
+
+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';\nimport settings from './settings';\nimport aiLocalizationJobs from './ai-localization-jobs';\n\nexport default {\n  locales,\n  'iso-locales': isoLocales,\n  'content-types': contentTypes,\n  settings,\n  'ai-localization-jobs': aiLocalizationJobs,\n};\n"],"names":["locales","isoLocales","contentTypes","settings","aiLocalizationJobs"],"mappings":";;;;;;AAMA,kBAAe;AACbA,aAAAA,UAAAA;IACA,aAAeC,EAAAA,YAAAA;IACf,eAAiBC,EAAAA,YAAAA;AACjBC,IAAAA,QAAAA;IACA,sBAAwBC,EAAAA;AAC1B,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;;;;"}