contentful-import 10.2.3 → 10.3.0

package/dist/index.mjs

@@ -2280,8 +2280,8 @@ function getNative(object, key) {
 var getNative_default = getNative;
 
 // node_modules/lodash-es/_WeakMap.js
-var WeakMap = getNative_default(root_default, "WeakMap");
-var WeakMap_default = WeakMap;
+var WeakMap2 = getNative_default(root_default, "WeakMap");
+var WeakMap_default = WeakMap2;
 
 // node_modules/lodash-es/_baseCreate.js
 var objectCreate = Object.create;
@@ -3007,12 +3007,12 @@ function memoize(func, resolver) {
     throw new TypeError(FUNC_ERROR_TEXT);
   }
   var memoized = function() {
-    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
-    if (cache.has(key)) {
-      return cache.get(key);
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache2 = memoized.cache;
+    if (cache2.has(key)) {
+      return cache2.get(key);
     }
     var result = func.apply(this, args);
-    memoized.cache = cache.set(key, result) || cache;
+    memoized.cache = cache2.set(key, result) || cache2;
     return result;
   };
   memoized.cache = new (memoize.Cache || MapCache_default)();
@@ -3025,12 +3025,12 @@ var memoize_default = memoize;
 var MAX_MEMOIZE_SIZE = 500;
 function memoizeCapped(func) {
   var result = memoize_default(func, function(key) {
-    if (cache.size === MAX_MEMOIZE_SIZE) {
-      cache.clear();
+    if (cache2.size === MAX_MEMOIZE_SIZE) {
+      cache2.clear();
     }
     return key;
   });
-  var cache = result.cache;
+  var cache2 = result.cache;
   return result;
 }
 var memoizeCapped_default = memoizeCapped;
@@ -4073,8 +4073,8 @@ function arraySome(array, predicate) {
 var arraySome_default = arraySome;
 
 // node_modules/lodash-es/_cacheHas.js
-function cacheHas(cache, key) {
-  return cache.has(key);
+function cacheHas(cache2, key) {
+  return cache2.has(key);
 }
 var cacheHas_default = cacheHas;
 
@@ -4855,7 +4855,7 @@ var startCase = createCompounder_default(function(result, word, index) {
 var startCase_default = startCase;
 
 // lib/index.ts
-var import_logging10 = __toESM(require_logging());
+var import_logging12 = __toESM(require_logging());
 var import_listr4 = __toESM(require_listr());
 import PQueue from "p-queue";
 
@@ -5210,7 +5210,7 @@ async function getDestinationData({
 }
 
 // lib/tasks/push-to-space/push-to-space.ts
-var import_logging9 = __toESM(require_logging());
+var import_logging11 = __toESM(require_logging());
 var import_listr2 = __toESM(require_listr());
 import Listr from "listr";
 import verboseRenderer from "listr-verbose-renderer";
@@ -5509,21 +5509,103 @@ function getPlainData(entity) {
 
 // lib/tasks/push-to-space/publishing.ts
 var import_get_entity_name3 = __toESM(require_get_entity_name());
+var import_logging7 = __toESM(require_logging());
+
+// lib/utils/locale-publishing.ts
 var import_logging6 = __toESM(require_logging());
-function publishEntity(client, spaceId, environmentId, entity) {
+var LOCALE_PUBLISHING_FEATURES = ["localeBasedPublishing", "localePublishing"];
+var ENABLE_ON_ENVIRONMENT = 'To preserve it, select "Locale-based (un)publishing" for the destination environment under Settings > Locales > Publishing options.';
+var NOT_ENTITLED = "Locale-based publishing is only available on some plans \u2014 contact Contentful to have it added.";
+async function spaceHasLocalePublishingEntitlement(client, spaceId) {
+  try {
+    const space = await client.space.get({ spaceId });
+    const organizationId = space.sys.organization?.sys?.id;
+    if (!organizationId) {
+      return null;
+    }
+    const entitlements = await client.raw.get(
+      `/organizations/${organizationId}/organization_entitlement_set`
+    );
+    const features = entitlements.features;
+    const known = LOCALE_PUBLISHING_FEATURES.filter((feature) => features?.[feature]?.value !== void 0);
+    if (!known.length) {
+      return null;
+    }
+    return known.some((feature) => features?.[feature]?.value === true);
+  } catch {
+    return null;
+  }
+}
+var localeScopingUnavailable = /* @__PURE__ */ new WeakSet();
+var entitlementChecks = /* @__PURE__ */ new WeakMap();
+async function ensureLocalePublishingEntitlement(client, spaceId) {
+  if (localeScopingUnavailable.has(client)) {
+    return;
+  }
+  let check = entitlementChecks.get(client);
+  if (!check) {
+    check = spaceHasLocalePublishingEntitlement(client, spaceId);
+    entitlementChecks.set(client, check);
+  }
+  if (await check === false) {
+    markLocaleScopingUnavailable(client, "The destination organization is not entitled to locale-based publishing.", NOT_ENTITLED);
+  }
+}
+function isLocaleScopingUnavailable(client) {
+  return localeScopingUnavailable.has(client);
+}
+function markLocaleScopingUnavailable(client, reason, remedy = ENABLE_ON_ENVIRONMENT) {
+  if (localeScopingUnavailable.has(client)) {
+    return;
+  }
+  localeScopingUnavailable.add(client);
+  import_logging6.logEmitter.emit("warning", `${reason} Publishing every locale instead \u2014 the per-locale publish state in the content file cannot be preserved. ${remedy}`);
+}
+function isLocalePublishingRejectedError(err) {
+  if (!(err instanceof Error)) {
+    return false;
+  }
+  const status = err.status ?? err.response?.status;
+  if (status === 403 || status === 400) {
+    return true;
+  }
+  try {
+    const parsed = JSON.parse(err.message)?.status;
+    return parsed === 403 || parsed === 400;
+  } catch {
+    return false;
+  }
+}
+function destinationScopedThePublish(publishedEntity) {
+  return Boolean(publishedEntity?.sys?.fieldStatus?.["*"]);
+}
+
+// lib/tasks/push-to-space/publishing.ts
+function publishEntity(client, spaceId, environmentId, entity, locales2) {
   const id = entity.sys.id;
   const type = entity.sys.type;
   if (type === "Entry") {
-    return client.entry.publish({ spaceId, environmentId, entryId: id }, entity);
+    return client.entry.publish({ spaceId, environmentId, entryId: id, locales: locales2 }, entity);
   }
   if (type === "Asset") {
-    return client.asset.publish({ spaceId, environmentId, assetId: id }, entity);
+    return client.asset.publish({ spaceId, environmentId, assetId: id, locales: locales2 }, entity);
   }
   if (type === "ContentType") {
     return client.contentType.publish({ spaceId, environmentId, contentTypeId: id }, entity);
   }
   throw new Error(`publishEntity: unsupported type "${type}"`);
 }
+function unpublishEntityLocales(client, spaceId, environmentId, entity, locales2) {
+  const id = entity.sys.id;
+  const type = entity.sys.type;
+  if (type === "Entry") {
+    return client.entry.unpublish({ spaceId, environmentId, entryId: id, locales: locales2 }, entity);
+  }
+  if (type === "Asset") {
+    return client.asset.unpublish({ spaceId, environmentId, assetId: id, locales: locales2 }, entity);
+  }
+  throw new Error(`unpublishEntityLocales: unsupported type "${type}"`);
+}
 function archiveEntity(client, spaceId, environmentId, entity) {
   const id = entity.sys.id;
   const type = entity.sys.type;
@@ -5535,26 +5617,26 @@ function archiveEntity(client, spaceId, environmentId, entity) {
   }
   throw new Error(`archiveEntity: unsupported type "${type}"`);
 }
-async function publishEntities({ entities, client, spaceId, environmentId, requestQueue }) {
+async function publishEntities({ entities, client, spaceId, environmentId, requestQueue, localePublishing }) {
   if (entities.length === 0) {
-    import_logging6.logEmitter.emit("info", "Skipping publishing since zero valid entities passed");
+    import_logging7.logEmitter.emit("info", "Skipping publishing since zero valid entities passed");
     return [];
   }
   const entity = entities[0];
   const type = entity.sys.type || "unknown type";
-  import_logging6.logEmitter.emit("info", `Publishing ${entities.length} ${type}s`);
-  const result = await runQueue(entities, [], client, spaceId, environmentId, requestQueue);
-  import_logging6.logEmitter.emit("info", `Successfully published ${result.length} ${type}s`);
+  import_logging7.logEmitter.emit("info", `Publishing ${entities.length} ${type}s`);
+  const result = await runQueue(entities, [], client, spaceId, environmentId, requestQueue, localePublishing);
+  import_logging7.logEmitter.emit("info", `Successfully published ${result.length} ${type}s`);
   return result;
 }
 async function archiveEntities({ entities, client, spaceId, environmentId, requestQueue }) {
   if (entities.length === 0) {
-    import_logging6.logEmitter.emit("info", "Skipping archiving since zero valid entities passed");
+    import_logging7.logEmitter.emit("info", "Skipping archiving since zero valid entities passed");
     return [];
   }
   const entity = entities[0];
   const type = entity.sys.type || "unknown type";
-  import_logging6.logEmitter.emit("info", `Archiving ${entities.length} ${type}s`);
+  import_logging7.logEmitter.emit("info", `Archiving ${entities.length} ${type}s`);
   const pendingArchivedEntities = entities.map((entity2) => {
     return requestQueue.add(async () => {
       try {
@@ -5564,28 +5646,66 @@ async function archiveEntities({ entities, client, spaceId, environmentId, reque
         if (err instanceof ContentfulEntityError) {
           err.entity = entity2;
         }
-        import_logging6.logEmitter.emit("error", err);
+        import_logging7.logEmitter.emit("error", err);
         return null;
       }
     });
   });
   const allPossiblyArchivedEntities = await Promise.all(pendingArchivedEntities);
   const allArchivedEntities = allPossiblyArchivedEntities.filter((entity2) => entity2);
-  import_logging6.logEmitter.emit("info", `Successfully archived ${allArchivedEntities.length} ${type}s`);
+  import_logging7.logEmitter.emit("info", `Successfully archived ${allArchivedEntities.length} ${type}s`);
   return allArchivedEntities;
 }
-async function runQueue(queue, result = [], client, spaceId, environmentId, requestQueue) {
+async function publishEntityLocales(client, spaceId, environmentId, entity, locales2, localesToDemote) {
+  let published;
+  try {
+    published = await publishEntity(client, spaceId, environmentId, entity, locales2);
+  } catch (err) {
+    if (!isLocalePublishingRejectedError(err)) {
+      throw err;
+    }
+    markLocaleScopingUnavailable(client, `The destination rejected locale-scoped publishing, starting with ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)}.`);
+    return publishEntity(client, spaceId, environmentId, entity);
+  }
+  if (!destinationScopedThePublish(published)) {
+    markLocaleScopingUnavailable(client, `The destination published ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)} without honouring the requested locales (${locales2.join(", ")}) and reported no per-locale state back.`);
+    return published;
+  }
+  if (!localesToDemote?.length) {
+    return published;
+  }
+  import_logging7.logEmitter.emit("info", `Unpublishing locales ${localesToDemote.join(", ")} of ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)}`);
+  try {
+    return await unpublishEntityLocales(client, spaceId, environmentId, published, localesToDemote);
+  } catch (err) {
+    if (isLocalePublishingRejectedError(err)) {
+      markLocaleScopingUnavailable(client, `The destination rejected locale-scoped unpublishing, starting with ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)}.`);
+      return published;
+    }
+    if (err instanceof ContentfulEntityError) {
+      err.entity = entity;
+    }
+    import_logging7.logEmitter.emit("error", err);
+    return published;
+  }
+}
+async function runQueue(queue, result = [], client, spaceId, environmentId, requestQueue, localePublishing) {
   const publishedEntities = [];
   for (const entity of queue) {
-    import_logging6.logEmitter.emit("info", `Publishing ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)}`);
+    const locales2 = localePublishing && !isLocaleScopingUnavailable(client) ? localePublishing.localesByEntityId.get(entity.sys.id) : void 0;
+    if (locales2) {
+      import_logging7.logEmitter.emit("info", `Publishing ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)} for locales ${locales2.join(", ")}`);
+    } else {
+      import_logging7.logEmitter.emit("info", `Publishing ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)}`);
+    }
     try {
-      const publishedEntity = await requestQueue.add(() => publishEntity(client, spaceId, environmentId, entity));
+      const publishedEntity = await requestQueue.add(() => locales2 ? publishEntityLocales(client, spaceId, environmentId, entity, locales2, localePublishing?.demoteLocalesByEntityId.get(entity.sys.id)) : publishEntity(client, spaceId, environmentId, entity));
       publishedEntities.push(publishedEntity);
     } catch (err) {
       if (err instanceof ContentfulEntityError) {
         err.entity = entity;
       }
-      import_logging6.logEmitter.emit("error", err);
+      import_logging7.logEmitter.emit("error", err);
     }
   }
   result = [
@@ -5597,9 +5717,9 @@ async function runQueue(queue, result = [], client, spaceId, environmentId, requ
   if (unpublishedEntities.length > 0) {
     if (queue.length === unpublishedEntities.length) {
       const unpublishedEntityNames = unpublishedEntities.map(import_get_entity_name3.default).join(", ");
-      import_logging6.logEmitter.emit("error", `Could not publish the following entities: ${unpublishedEntityNames}`);
+      import_logging7.logEmitter.emit("error", `Could not publish the following entities: ${unpublishedEntityNames}`);
     } else {
-      return runQueue(unpublishedEntities, result, client, spaceId, environmentId, requestQueue);
+      return runQueue(unpublishedEntities, result, client, spaceId, environmentId, requestQueue, localePublishing);
     }
   }
   return result;
@@ -5731,18 +5851,18 @@ function sortExperienceFragments(experienceFragments) {
 }
 
 // lib/utils/sort-or-report.ts
-var import_logging7 = __toESM(require_logging());
+var import_logging8 = __toESM(require_logging());
 function sortOrReport(sortFn) {
   try {
     return sortFn();
   } catch (err) {
-    import_logging7.logEmitter.emit("error", err);
+    import_logging8.logEmitter.emit("error", err);
     throw err;
   }
 }
 
 // lib/utils/import-exo-folders.ts
-var import_logging8 = __toESM(require_logging());
+var import_logging9 = __toESM(require_logging());
 var FOLDER_CONCEPT_PREFIX = "contentful.folder-";
 var PARENT_FOLDER_GROUP_IDS = {
   designToken: "contentful.folder-group-designToken",
@@ -5812,7 +5932,7 @@ async function createOrPatchChildConcepts(client, organizationId, destinationSpa
       existing = await client.concept.get({ organizationId, conceptId: destConceptId });
     } catch (err) {
       if (err?.name !== "NotFound") {
-        import_logging8.logEmitter.emit("warning", `Could not fetch destination child concept ${destConceptId}: ${err?.message ?? err}`);
+        import_logging9.logEmitter.emit("warning", `Could not fetch destination child concept ${destConceptId}: ${err?.message ?? err}`);
       }
     }
     if (!existing) {
@@ -5822,9 +5942,9 @@ async function createOrPatchChildConcepts(client, organizationId, destinationSpa
           // @ts-expect-error - CMA.js type needs to be updated to be aware of purpose: 'internal'
           { purpose: "internal", prefLabel, metadata: { spaces: [spaceLink] } }
         );
-        import_logging8.logEmitter.emit("info", `Created child folder concept ${destConceptId}`);
+        import_logging9.logEmitter.emit("info", `Created child folder concept ${destConceptId}`);
       } catch (err) {
-        import_logging8.logEmitter.emit("error", `Failed to create child folder concept ${destConceptId}: ${err?.message ?? err}`);
+        import_logging9.logEmitter.emit("error", `Failed to create child folder concept ${destConceptId}: ${err?.message ?? err}`);
       }
     } else {
       const patches = [];
@@ -5838,9 +5958,9 @@ async function createOrPatchChildConcepts(client, organizationId, destinationSpa
             { organizationId, conceptId: destConceptId, version: existing.sys.version },
             patches
           );
-          import_logging8.logEmitter.emit("info", `Patched child folder concept ${destConceptId} (${patches.map((p) => p.path).join(", ")})`);
+          import_logging9.logEmitter.emit("info", `Patched child folder concept ${destConceptId} (${patches.map((p) => p.path).join(", ")})`);
         } catch (err) {
-          import_logging8.logEmitter.emit("error", `Failed to patch child folder concept ${destConceptId}: ${err?.message ?? err}`);
+          import_logging9.logEmitter.emit("error", `Failed to patch child folder concept ${destConceptId}: ${err?.message ?? err}`);
         }
       }
     }
@@ -5858,9 +5978,9 @@ async function linkChildConceptsToParentGroups(client, organizationId, childConc
         [{ op: "add", path: "/concepts/-", value: { sys: { type: "Link", linkType: "TaxonomyConcept", id: destConceptId } } }]
       );
       parentGroups.set(parentGroupId, updated);
-      import_logging8.logEmitter.emit("info", `Linked child concept ${destConceptId} to parent group ${parentGroupId}`);
+      import_logging9.logEmitter.emit("info", `Linked child concept ${destConceptId} to parent group ${parentGroupId}`);
     } catch (err) {
-      import_logging8.logEmitter.emit("error", `Failed to link child concept ${destConceptId} to parent group ${parentGroupId}: ${err?.message ?? err}`);
+      import_logging9.logEmitter.emit("error", `Failed to link child concept ${destConceptId} to parent group ${parentGroupId}: ${err?.message ?? err}`);
     }
   }
 }
@@ -5882,17 +6002,17 @@ async function importExoFolders({
 }) {
   const sourceSpaceId = getSourceSpaceId(sourceEntities);
   if (sourceSpaceId === destinationSpaceId) {
-    import_logging8.logEmitter.emit("info", "Source and destination space are the same \u2014 skipping ExO folder import");
+    import_logging9.logEmitter.emit("info", "Source and destination space are the same \u2014 skipping ExO folder import");
     return;
   }
   const parentGroups = await ensureParentFolderGroupsExist(client, organizationId);
   if (parentGroups.size === 0) {
-    import_logging8.logEmitter.emit("warn", "One or more Experience Orchestration folder group concept schemes are missing in the destination organization. Please create them before importing.");
+    import_logging9.logEmitter.emit("warn", "One or more Experience Orchestration folder group concept schemes are missing in the destination organization. Please create them before importing.");
     return;
   }
   const childConceptMap = deriveChildConceptMap(sourceEntities, destinationSpaceId);
   if (childConceptMap.size === 0) return;
-  import_logging8.logEmitter.emit("info", `Importing ${childConceptMap.size} ExO folder concept(s) into destination space ${destinationSpaceId}`);
+  import_logging9.logEmitter.emit("info", `Importing ${childConceptMap.size} ExO folder concept(s) into destination space ${destinationSpaceId}`);
   await createOrPatchChildConcepts(client, organizationId, destinationSpaceId, childConceptMap);
   await linkChildConceptsToParentGroups(client, organizationId, childConceptMap, parentGroups);
   const allEntities = [
@@ -5905,6 +6025,79 @@ async function importExoFolders({
   rewriteEntityFolderConcepts(allEntities, childConceptMap);
 }
 
+// lib/utils/resolve-publish-locales.ts
+var LIVE_FIELD_STATUSES = ["published", "changed"];
+function resolvePublishLocales(sys, destinationLocaleCodes) {
+  const fieldStatus = sys.fieldStatus?.["*"];
+  if (!fieldStatus || !destinationLocaleCodes) {
+    return null;
+  }
+  const liveLocales = Object.keys(fieldStatus).filter((locale) => LIVE_FIELD_STATUSES.indexOf(fieldStatus[locale]) !== -1);
+  const availableLocales = liveLocales.filter((locale) => destinationLocaleCodes.indexOf(locale) !== -1);
+  if (availableLocales.length === 0) {
+    return [];
+  }
+  const everyLocaleIsLive = destinationLocaleCodes.every((locale) => availableLocales.indexOf(locale) !== -1);
+  return everyLocaleIsLive ? null : availableLocales;
+}
+function resolveLocalesToDemote(sys, destinationSys, destinationLocaleCodes) {
+  const fieldStatus = sys.fieldStatus?.["*"];
+  const destinationFieldStatus = destinationSys?.fieldStatus?.["*"];
+  if (!fieldStatus || !destinationFieldStatus) {
+    return [];
+  }
+  return Object.keys(fieldStatus).filter((locale) => fieldStatus[locale] === "draft").filter((locale) => destinationLocaleCodes.indexOf(locale) !== -1).filter((locale) => LIVE_FIELD_STATUSES.indexOf(destinationFieldStatus[locale]) !== -1);
+}
+function buildLocalePublishPlan(sourceEntities, destinationLocaleCodes, { destinationEntitiesById } = {}) {
+  const localesByEntityId = /* @__PURE__ */ new Map();
+  const skippedEntityIds = /* @__PURE__ */ new Set();
+  const demoteLocalesByEntityId = /* @__PURE__ */ new Map();
+  for (const { original } of sourceEntities) {
+    const locales2 = resolvePublishLocales(original.sys, destinationLocaleCodes);
+    if (locales2 === null) {
+      continue;
+    }
+    if (locales2.length === 0) {
+      skippedEntityIds.add(original.sys.id);
+      continue;
+    }
+    localesByEntityId.set(original.sys.id, locales2);
+    if (!destinationEntitiesById) {
+      continue;
+    }
+    const localesToDemote = resolveLocalesToDemote(
+      original.sys,
+      destinationEntitiesById.get(original.sys.id)?.sys,
+      destinationLocaleCodes
+    );
+    if (localesToDemote.length) {
+      demoteLocalesByEntityId.set(original.sys.id, localesToDemote);
+    }
+  }
+  return { localesByEntityId, skippedEntityIds, demoteLocalesByEntityId };
+}
+
+// lib/utils/destination-locales.ts
+var import_logging10 = __toESM(require_logging());
+var cache = /* @__PURE__ */ new WeakMap();
+function getDestinationLocaleCodes({ client, spaceId, environmentId, requestQueue }) {
+  let byEnvironment = cache.get(client);
+  if (!byEnvironment) {
+    byEnvironment = /* @__PURE__ */ new Map();
+    cache.set(client, byEnvironment);
+  }
+  const key = `${spaceId}/${environmentId}`;
+  let localeCodes = byEnvironment.get(key);
+  if (!localeCodes) {
+    localeCodes = batchedPageQuery({ client, spaceId, environmentId, type: "locales", requestQueue }).then((items) => items.map((locale) => locale.code)).catch((err) => {
+      import_logging10.logEmitter.emit("warning", `Could not read the locales of the destination environment, falling back to publishing all locales: ${err.message}`);
+      return null;
+    });
+    byEnvironment.set(key, localeCodes);
+  }
+  return localeCodes;
+}
+
 // lib/tasks/push-to-space/push-to-space.ts
 async function withGraphQLSchemaBackoff(fn) {
   let lastErr;
@@ -5916,7 +6109,7 @@ async function withGraphQLSchemaBackoff(fn) {
         throw err;
       }
       const delay = GRAPHQL_SCHEMA_STALE_DELAYS_MS[attempt];
-      import_logging9.logEmitter.emit("warning", `DataAssembly GraphQL schema not yet current, retrying in ${delay}ms (attempt ${attempt + 1}/${GRAPHQL_SCHEMA_STALE_DELAYS_MS.length})`);
+      import_logging11.logEmitter.emit("warning", `DataAssembly GraphQL schema not yet current, retrying in ${delay}ms (attempt ${attempt + 1}/${GRAPHQL_SCHEMA_STALE_DELAYS_MS.length})`);
       await new Promise((resolve2) => setTimeout(resolve2, delay));
       lastErr = err;
     }
@@ -5944,6 +6137,7 @@ function pushToSpace({
   skipContentUpdates,
   skipLocales,
   skipContentPublishing,
+  unpublishDraftLocales,
   timeout,
   retryLimit,
   listrOptions,
@@ -6055,7 +6249,7 @@ function pushToSpace({
             const ctEditorInterface = await requestQueue.add(
               () => client.editorInterface.get({ spaceId, environmentId, contentTypeId: contentType.sys.id })
             );
-            import_logging9.logEmitter.emit("info", `Fetched editor interface for ${contentType.name}`);
+            import_logging11.logEmitter.emit("info", `Fetched editor interface for ${contentType.name}`);
             const updatedData = {
               ...ctEditorInterface,
               controls: editorInterface.controls,
@@ -6073,7 +6267,7 @@ function pushToSpace({
             return updatedEditorInterface;
           } catch (err) {
             err.entity = editorInterface;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
             return null;
           }
         });
@@ -6091,7 +6285,7 @@ function pushToSpace({
           for (const file of Object.values(asset.transformed.fields.file)) {
             allPendingUploads.push(requestQueue.add(async () => {
               try {
-                import_logging9.logEmitter.emit("info", `Uploading Asset file ${file.upload}`);
+                import_logging11.logEmitter.emit("info", `Uploading Asset file ${file.upload}`);
                 const assetStream = await getAssetStreamForURL(file.upload, assetsDirectory);
                 const upload = await client.upload.create(
                   { spaceId, environmentId },
@@ -6107,7 +6301,7 @@ function pushToSpace({
                 };
                 return upload;
               } catch (err) {
-                import_logging9.logEmitter.emit("error", err);
+                import_logging11.logEmitter.emit("error", err);
               }
             }));
           }
@@ -6152,7 +6346,8 @@ function pushToSpace({
           client,
           spaceId,
           environmentId,
-          requestQueue
+          requestQueue,
+          destinationEntitiesById: unpublishDraftLocales ? destinationDataById.assets : void 0
         });
         ctx.data.publishedAssets = publishedAssets;
       }),
@@ -6196,7 +6391,8 @@ function pushToSpace({
           client,
           spaceId,
           environmentId,
-          requestQueue
+          requestQueue,
+          destinationEntitiesById: unpublishDraftLocales ? destinationDataById.entries : void 0
         });
         ctx.data.publishedEntries = publishedEntries;
       }),
@@ -6251,7 +6447,7 @@ function pushToSpace({
             }
           });
         } catch (error) {
-          import_logging9.logEmitter.emit("warning", `Unable to create Experience Orchestration (ExO) folders, error: ${error}`);
+          import_logging11.logEmitter.emit("warning", `Unable to create Experience Orchestration (ExO) folders, error: ${error}`);
         }
       }),
       skip: () => !includeExperienceOrchestration
@@ -6269,19 +6465,19 @@ function pushToSpace({
                 { spaceId, environmentId, dataAssemblyId: entity.sys.id },
                 payload
               ));
-              import_logging9.logEmitter.emit("info", `UPDATE DataAssembly ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `UPDATE DataAssembly ${entity.sys.id}`);
             } else {
               const payload = { ...omitSys(entity), sys: buildDataAssemblySys(entity, 0) };
               result = await withGraphQLSchemaBackoff(() => client.dataAssembly.update(
                 { spaceId, environmentId, dataAssemblyId: entity.sys.id },
                 payload
               ));
-              import_logging9.logEmitter.emit("info", `CREATE DataAssembly ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `CREATE DataAssembly ${entity.sys.id}`);
             }
             return result;
           } catch (err) {
             err.entity = entity;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
             return null;
           }
         }));
@@ -6311,17 +6507,17 @@ function pushToSpace({
             if (existing) {
               const payload = { ...entity, sys: { id: entity.sys.id, type: "DesignToken", version: existing.sys.version } };
               const result = await client.designToken.upsert({ spaceId, environmentId, designTokenId: entity.sys.id }, payload);
-              import_logging9.logEmitter.emit("info", `UPDATE DesignToken ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `UPDATE DesignToken ${entity.sys.id}`);
               return result;
             } else {
               const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "DesignToken" } };
               const result = await client.designToken.upsert({ spaceId, environmentId, designTokenId: entity.sys.id }, payload);
-              import_logging9.logEmitter.emit("info", `CREATE DesignToken ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `CREATE DesignToken ${entity.sys.id}`);
               return result;
             }
           } catch (err) {
             err.entity = entity;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
             return null;
           }
         }));
@@ -6340,17 +6536,17 @@ function pushToSpace({
             if (existing) {
               const payload = { ...entity, sys: { id: entity.sys.id, type: "Component", version: existing.sys.version } };
               const result = await client.component.upsert({ spaceId, environmentId, componentId: entity.sys.id }, payload);
-              import_logging9.logEmitter.emit("info", `UPDATE Component ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `UPDATE Component ${entity.sys.id}`);
               results.push(result);
             } else {
               const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "Component" } };
               const result = await client.component.upsert({ spaceId, environmentId, componentId: entity.sys.id }, payload);
-              import_logging9.logEmitter.emit("info", `CREATE Component ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `CREATE Component ${entity.sys.id}`);
               results.push(result);
             }
           } catch (err) {
             err.entity = entity;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
           }
         }
         ctx.data.components = results;
@@ -6382,17 +6578,17 @@ function pushToSpace({
             if (existing) {
               const payload = { ...entity, sys: { id: entity.sys.id, type: "ExperienceTemplate", version: existing.sys.version } };
               const result = await client.experienceTemplate.upsert({ spaceId, environmentId, experienceTemplateId: entity.sys.id }, payload);
-              import_logging9.logEmitter.emit("info", `UPDATE ExperienceTemplate ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `UPDATE ExperienceTemplate ${entity.sys.id}`);
               return result;
             } else {
               const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "ExperienceTemplate" } };
               const result = await client.experienceTemplate.upsert({ spaceId, environmentId, experienceTemplateId: entity.sys.id }, payload);
-              import_logging9.logEmitter.emit("info", `CREATE ExperienceTemplate ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `CREATE ExperienceTemplate ${entity.sys.id}`);
               return result;
             }
           } catch (err) {
             err.entity = entity;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
             return null;
           }
         }));
@@ -6424,17 +6620,17 @@ function pushToSpace({
             if (existing) {
               const payload = { ...entity, sys: { id: entity.sys.id, type: "ExperienceFragment", version: existing.sys.version } };
               const result = await client.experienceFragment.upsert({ spaceId, environmentId, experienceFragmentId: entity.sys.id }, payload);
-              import_logging9.logEmitter.emit("info", `UPDATE ExperienceFragment ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `UPDATE ExperienceFragment ${entity.sys.id}`);
               results.push(result);
             } else {
               const payload = { ...omitSys(entity), component: entity.sys.component, sys: { id: entity.sys.id, type: "ExperienceFragment" } };
               const result = await client.experienceFragment.upsert({ spaceId, environmentId, experienceFragmentId: entity.sys.id }, payload);
-              import_logging9.logEmitter.emit("info", `CREATE ExperienceFragment ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `CREATE ExperienceFragment ${entity.sys.id}`);
               results.push(result);
             }
           } catch (err) {
             err.entity = entity;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
           }
         }
         ctx.data.experienceFragments = results;
@@ -6466,17 +6662,17 @@ function pushToSpace({
             if (existing) {
               const payload = { ...entity, sys: { id: entity.sys.id, type: "Experience", version: existing.sys.version } };
               const result = await client.experience.upsert({ spaceId, environmentId, experienceId: entity.sys.id }, payload);
-              import_logging9.logEmitter.emit("info", `UPDATE Experience ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `UPDATE Experience ${entity.sys.id}`);
               return result;
             } else {
               const payload = { ...omitSys(entity), experienceTemplate: entity.sys.experienceTemplate, sys: { id: entity.sys.id, type: "Experience" } };
               const result = await client.experience.upsert({ spaceId, environmentId, experienceId: entity.sys.id }, payload);
-              import_logging9.logEmitter.emit("info", `CREATE Experience ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `CREATE Experience ${entity.sys.id}`);
               return result;
             }
           } catch (err) {
             err.entity = entity;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
             return null;
           }
         }));
@@ -6573,10 +6769,41 @@ function archiveEntities2({ entities, sourceEntities, client, spaceId, environme
   const entitiesToArchive = entities.filter((entity) => entityIdsToArchive.indexOf(entity.sys.id) !== -1);
   return archiveEntities({ entities: entitiesToArchive, client, spaceId, environmentId, requestQueue });
 }
-function publishEntities2({ entities, sourceEntities, client, spaceId, environmentId, requestQueue }) {
+async function publishEntities2({ entities, sourceEntities, client, spaceId, environmentId, requestQueue, destinationEntitiesById }) {
   const entityIdsToPublish = sourceEntities.filter(({ original }) => original.sys.publishedVersion).map(({ original }) => original.sys.id);
-  const entitiesToPublish = entities.filter((entity) => entityIdsToPublish.indexOf(entity.sys.id) !== -1);
-  return publishEntities({ entities: entitiesToPublish, client, spaceId, environmentId, requestQueue });
+  let entitiesToPublish = entities.filter((entity) => entityIdsToPublish.indexOf(entity.sys.id) !== -1);
+  const publishAllLocales = () => publishEntities({ entities: entitiesToPublish, client, spaceId, environmentId, requestQueue });
+  const hasFieldStatus = sourceEntities.some(({ original }) => original.sys.fieldStatus);
+  if (!hasFieldStatus) {
+    return publishAllLocales();
+  }
+  await ensureLocalePublishingEntitlement(client, spaceId);
+  if (isLocaleScopingUnavailable(client)) {
+    return publishAllLocales();
+  }
+  const destinationLocaleCodes = await getDestinationLocaleCodes({ client, spaceId, environmentId, requestQueue });
+  const localePublishing = buildLocalePublishPlan(
+    sourceEntities,
+    destinationLocaleCodes,
+    { destinationEntitiesById }
+  );
+  if (localePublishing.skippedEntityIds.size) {
+    entitiesToPublish = entitiesToPublish.filter((entity) => {
+      if (!localePublishing.skippedEntityIds.has(entity.sys.id)) {
+        return true;
+      }
+      import_logging11.logEmitter.emit("warning", `Not publishing ${entity.sys.type} ${entity.sys.id} because none of the locales it was published for exist in the destination environment`);
+      return false;
+    });
+  }
+  return publishEntities({
+    entities: entitiesToPublish,
+    client,
+    spaceId,
+    environmentId,
+    requestQueue,
+    localePublishing
+  });
 }
 
 // lib/transform/transformers.ts
@@ -7113,6 +7340,7 @@ async function parseOptions(params) {
     skipContentModel: false,
     skipLocales: false,
     skipContentPublishing: false,
+    unpublishDraftLocales: false,
     skipAssetUpdates: false,
     skipContentUpdates: false,
     useVerboseRenderer: false,
@@ -7221,7 +7449,7 @@ async function runContentfulImport(params) {
     intervalCap: options.rateLimit,
     carryoverConcurrencyCount: true
   });
-  (0, import_logging10.setupLogging)(log);
+  (0, import_logging12.setupLogging)(log);
   const infoTable = new Table(tableOptions);
   infoTable.push([{ colSpan: 2, content: "The following entities are going to be imported:" }]);
   Object.keys(options.content).forEach((type) => {
@@ -7289,6 +7517,7 @@ async function runContentfulImport(params) {
           skipLocales: options.skipLocales,
           skipContentModel: options.skipContentModel,
           skipContentPublishing: options.skipContentPublishing,
+          unpublishDraftLocales: options.unpublishDraftLocales,
           skipAssetUpdates: options.skipAssetUpdates,
           skipContentUpdates: options.skipContentUpdates,
           timeout: options.timeout,
@@ -7330,9 +7559,9 @@ async function runContentfulImport(params) {
   }).then((data) => {
     const errorLog = log.filter((logMessage) => logMessage.level !== "info" && logMessage.level !== "warning");
     const displayLog = log.filter((logMessage) => logMessage.level !== "info");
-    (0, import_logging10.displayErrorLog)(displayLog);
+    (0, import_logging12.displayErrorLog)(displayLog);
     if (errorLog.length) {
-      return (0, import_logging10.writeErrorLogFile)(options.errorLogFile, errorLog).then(() => {
+      return (0, import_logging12.writeErrorLogFile)(options.errorLogFile, errorLog).then(() => {
         const multiError = new ContentfulMultiError("Errors occurred");
         multiError.name = "ContentfulMultiError";
         multiError.errors = errorLog;