@sanity/document-internationalization 3.0.1 → 3.2.0

package/dist/index.esm.js

@@ -1,12 +1,12 @@
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
-import { TrashIcon, CogIcon, SplitVerticalIcon, CheckmarkIcon, AddIcon, EditIcon, TranslateIcon, InfoOutlineIcon } from "@sanity/icons";
+import { TrashIcon, CopyIcon, CogIcon, SplitVerticalIcon, CheckmarkIcon, AddIcon, EditIcon, TranslateIcon, InfoOutlineIcon } from "@sanity/icons";
 import { Flex, Spinner, Stack, Text, Card, Grid, Button, useToast, Tooltip, Box, Badge, useClickOutside, TextInput, Popover, Inline, Dialog } from "@sanity/ui";
 import { useMemo, useEffect, createContext, useContext, useState, useCallback } from "react";
-import { useSchema, Preview, useClient, useWorkspace, isDocumentSchemaType, pathToString, useEditState, useValidationStatus, TextWithTone, PatchEvent, unset, defineType, defineField, definePlugin, isSanityDocument } from "sanity";
+import { useSchema, Preview, useClient, useWorkspace, defineLocaleResourceBundle, useDocumentStore, useDocumentOperation, useDocumentPairPermissions, DEFAULT_STUDIO_CLIENT_OPTIONS, useTranslation, useCurrentUser, InsufficientPermissionsMessage, isDocumentSchemaType, pathToString, useEditState, useValidationStatus, TextWithTone, PatchEvent, unset, defineType, defineField, definePlugin, isSanityDocument } from "sanity";
 import { Feedback, useListeningQuery } from "sanity-plugin-utils";
 import { uuid } from "@sanity/uuid";
-import { RouterContext } from "sanity/router";
-import { usePaneRouter, useDocumentPane } from "sanity/structure";
+import { useRouter, RouterContext } from "sanity/router";
+import { structureLocaleNamespace, usePaneRouter, useDocumentPane } from "sanity/structure";
 import { Mutation, extractWithPath } from "@sanity/mutator";
 import { styled } from "styled-components";
 import { internationalizedArray } from "sanity-plugin-internationalized-array";
@@ -21,7 +21,8 @@ const METADATA_SCHEMA_NAME = "translation.metadata", TRANSLATIONS_ARRAY_NAME = "
   weakReferences: !1,
   bulkPublish: !1,
   metadataFields: [],
-  apiVersion: API_VERSION
+  apiVersion: API_VERSION,
+  allowCreateMetaDoc: !1
 };
 function separateReferences(data = []) {
   const translations = [], otherReferences = [];
@@ -110,7 +111,7 @@ function shallowEqualArrays(arrA, arrB, equal = (a, b) => a === b) {
       return !1;
   return !0;
 }
-function query$1(fn, keys = null, preload = !1, config = {}) {
+function query$1(fn, keys = null, preload = !1, config2 = {}) {
   keys === null && (keys = [fn]);
   for (const entry2 of globalCache)
     if (shallowEqualArrays(keys, entry2.keys, entry2.equal)) {
@@ -119,13 +120,13 @@ function query$1(fn, keys = null, preload = !1, config = {}) {
       if (Object.prototype.hasOwnProperty.call(entry2, "error"))
         throw entry2.error;
       if (Object.prototype.hasOwnProperty.call(entry2, "response"))
-        return config.lifespan && config.lifespan > 0 && (entry2.timeout && clearTimeout(entry2.timeout), entry2.timeout = setTimeout(entry2.remove, config.lifespan)), entry2.response;
+        return config2.lifespan && config2.lifespan > 0 && (entry2.timeout && clearTimeout(entry2.timeout), entry2.timeout = setTimeout(entry2.remove, config2.lifespan)), entry2.response;
       if (!preload)
         throw entry2.promise;
     }
   const entry = {
     keys,
-    equal: config.equal,
+    equal: config2.equal,
     remove: () => {
       const index = globalCache.indexOf(entry);
       index !== -1 && globalCache.splice(index, 1);
@@ -133,14 +134,14 @@ function query$1(fn, keys = null, preload = !1, config = {}) {
     promise: (
       // Execute the promise
       (isPromise(fn) ? fn : fn(...keys)).then((response) => {
-        entry.response = response, config.lifespan && config.lifespan > 0 && (entry.timeout = setTimeout(entry.remove, config.lifespan));
+        entry.response = response, config2.lifespan && config2.lifespan > 0 && (entry.timeout = setTimeout(entry.remove, config2.lifespan));
       }).catch((error) => entry.error = error)
     )
   };
   if (globalCache.push(entry), !preload)
     throw entry.promise;
 }
-const suspend = (fn, keys, config) => query$1(fn, keys, !1, config), DocumentInternationalizationContext = createContext(DEFAULT_CONFIG);
+const suspend = (fn, keys, config2) => query$1(fn, keys, !1, config2), DocumentInternationalizationContext = createContext(DEFAULT_CONFIG);
 function useDocumentInternationalizationContext() {
   return useContext(DocumentInternationalizationContext);
 }
@@ -212,7 +213,392 @@ const DeleteTranslationAction = (props) => {
       )
     }
   };
-}, query = `*[_type == $translationSchema && $id in translations[].value._ref]{
+};
+var extendStatics = function(d, b) {
+  return extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2)
+      Object.prototype.hasOwnProperty.call(b2, p) && (d2[p] = b2[p]);
+  }, extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b != "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __values(o) {
+  var s = typeof Symbol == "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m)
+    return m.call(o);
+  if (o && typeof o.length == "number")
+    return {
+      next: function() {
+        return o && i >= o.length && (o = void 0), { value: o && o[i++], done: !o };
+      }
+    };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol == "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    for (; (n === void 0 || n-- > 0) && !(r = i.next()).done; )
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      r && !r.done && (m = i.return) && m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+}
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2)
+    for (var i = 0, l = from.length, ar; i < l; i++)
+      (ar || !(i in from)) && (ar || (ar = Array.prototype.slice.call(from, 0, i)), ar[i] = from[i]);
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+function isFunction(value) {
+  return typeof value == "function";
+}
+function createErrorClass(createImpl) {
+  var _super = function(instance) {
+    Error.call(instance), instance.stack = new Error().stack;
+  }, ctorFunc = createImpl(_super);
+  return ctorFunc.prototype = Object.create(Error.prototype), ctorFunc.prototype.constructor = ctorFunc, ctorFunc;
+}
+var UnsubscriptionError = createErrorClass(function(_super) {
+  return function(errors) {
+    _super(this), this.message = errors ? errors.length + ` errors occurred during unsubscription:
+` + errors.map(function(err, i) {
+      return i + 1 + ") " + err.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = errors;
+  };
+});
+function arrRemove(arr, item) {
+  if (arr) {
+    var index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
+  }
+}
+var Subscription = function() {
+  function Subscription2(initialTeardown) {
+    this.initialTeardown = initialTeardown, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return Subscription2.prototype.unsubscribe = function() {
+    var e_1, _a, e_2, _b, errors;
+    if (!this.closed) {
+      this.closed = !0;
+      var _parentage = this._parentage;
+      if (_parentage)
+        if (this._parentage = null, Array.isArray(_parentage))
+          try {
+            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+              var parent_1 = _parentage_1_1.value;
+              parent_1.remove(this);
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              _parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return) && _a.call(_parentage_1);
+            } finally {
+              if (e_1)
+                throw e_1.error;
+            }
+          }
+        else
+          _parentage.remove(this);
+      var initialFinalizer = this.initialTeardown;
+      if (isFunction(initialFinalizer))
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = e instanceof UnsubscriptionError ? e.errors : [e];
+        }
+      var _finalizers = this._finalizers;
+      if (_finalizers) {
+        this._finalizers = null;
+        try {
+          for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+            var finalizer = _finalizers_1_1.value;
+            try {
+              execFinalizer(finalizer);
+            } catch (err) {
+              errors = errors != null ? errors : [], err instanceof UnsubscriptionError ? errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors)) : errors.push(err);
+            }
+          }
+        } catch (e_2_1) {
+          e_2 = { error: e_2_1 };
+        } finally {
+          try {
+            _finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return) && _b.call(_finalizers_1);
+          } finally {
+            if (e_2)
+              throw e_2.error;
+          }
+        }
+      }
+      if (errors)
+        throw new UnsubscriptionError(errors);
+    }
+  }, Subscription2.prototype.add = function(teardown) {
+    var _a;
+    if (teardown && teardown !== this)
+      if (this.closed)
+        execFinalizer(teardown);
+      else {
+        if (teardown instanceof Subscription2) {
+          if (teardown.closed || teardown._hasParent(this))
+            return;
+          teardown._addParent(this);
+        }
+        (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+      }
+  }, Subscription2.prototype._hasParent = function(parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  }, Subscription2.prototype._addParent = function(parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+  }, Subscription2.prototype._removeParent = function(parent) {
+    var _parentage = this._parentage;
+    _parentage === parent ? this._parentage = null : Array.isArray(_parentage) && arrRemove(_parentage, parent);
+  }, Subscription2.prototype.remove = function(teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown), teardown instanceof Subscription2 && teardown._removeParent(this);
+  }, Subscription2.EMPTY = function() {
+    var empty = new Subscription2();
+    return empty.closed = !0, empty;
+  }(), Subscription2;
+}();
+function isSubscription(value) {
+  return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+}
+function execFinalizer(finalizer) {
+  isFunction(finalizer) ? finalizer() : finalizer.unsubscribe();
+}
+var config = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: !1,
+  useDeprecatedNextContext: !1
+}, timeoutProvider = {
+  setTimeout: function(handler, timeout) {
+    for (var args = [], _i = 2; _i < arguments.length; _i++)
+      args[_i - 2] = arguments[_i];
+    return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+  },
+  clearTimeout: function(handle) {
+    return clearTimeout(handle);
+  },
+  delegate: void 0
+};
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function() {
+    throw err;
+  });
+}
+function noop() {
+}
+var Subscriber = function(_super) {
+  __extends(Subscriber2, _super);
+  function Subscriber2(destination) {
+    var _this = _super.call(this) || this;
+    return _this.isStopped = !1, destination ? (_this.destination = destination, isSubscription(destination) && destination.add(_this)) : _this.destination = EMPTY_OBSERVER, _this;
+  }
+  return Subscriber2.create = function(next, error, complete) {
+    return new SafeSubscriber(next, error, complete);
+  }, Subscriber2.prototype.next = function(value) {
+    this.isStopped || this._next(value);
+  }, Subscriber2.prototype.error = function(err) {
+    this.isStopped || (this.isStopped = !0, this._error(err));
+  }, Subscriber2.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, Subscriber2.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, _super.prototype.unsubscribe.call(this), this.destination = null);
+  }, Subscriber2.prototype._next = function(value) {
+    this.destination.next(value);
+  }, Subscriber2.prototype._error = function(err) {
+    try {
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
+    }
+  }, Subscriber2.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, Subscriber2;
+}(Subscription), _bind = Function.prototype.bind;
+function bind(fn, thisArg) {
+  return _bind.call(fn, thisArg);
+}
+var ConsumerObserver = function() {
+  function ConsumerObserver2(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  return ConsumerObserver2.prototype.next = function(value) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.next)
+      try {
+        partialObserver.next(value);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+  }, ConsumerObserver2.prototype.error = function(err) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.error)
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    else
+      handleUnhandledError(err);
+  }, ConsumerObserver2.prototype.complete = function() {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete)
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+  }, ConsumerObserver2;
+}(), SafeSubscriber = function(_super) {
+  __extends(SafeSubscriber2, _super);
+  function SafeSubscriber2(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this, partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext)
+      partialObserver = {
+        next: observerOrNext != null ? observerOrNext : void 0,
+        error: error != null ? error : void 0,
+        complete: complete != null ? complete : void 0
+      };
+    else {
+      var context_1;
+      _this && config.useDeprecatedNextContext ? (context_1 = Object.create(observerOrNext), context_1.unsubscribe = function() {
+        return _this.unsubscribe();
+      }, partialObserver = {
+        next: observerOrNext.next && bind(observerOrNext.next, context_1),
+        error: observerOrNext.error && bind(observerOrNext.error, context_1),
+        complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
+      }) : partialObserver = observerOrNext;
+    }
+    return _this.destination = new ConsumerObserver(partialObserver), _this;
+  }
+  return SafeSubscriber2;
+}(Subscriber);
+function handleUnhandledError(error) {
+  reportUnhandledError(error);
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+var EMPTY_OBSERVER = {
+  closed: !0,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+function hasLift(source) {
+  return isFunction(source == null ? void 0 : source.lift);
+}
+function operate(init) {
+  return function(source) {
+    if (hasLift(source))
+      return source.lift(function(liftedSource) {
+        try {
+          return init(liftedSource, this);
+        } catch (err) {
+          this.error(err);
+        }
+      });
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+  return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = function(_super) {
+  __extends(OperatorSubscriber2, _super);
+  function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+    var _this = _super.call(this, destination) || this;
+    return _this.onFinalize = onFinalize, _this.shouldUnsubscribe = shouldUnsubscribe, _this._next = onNext ? function(value) {
+      try {
+        onNext(value);
+      } catch (err) {
+        destination.error(err);
+      }
+    } : _super.prototype._next, _this._error = onError ? function(err) {
+      try {
+        onError(err);
+      } catch (err2) {
+        destination.error(err2);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._error, _this._complete = onComplete ? function() {
+      try {
+        onComplete();
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._complete, _this;
+  }
+  return OperatorSubscriber2.prototype.unsubscribe = function() {
+    var _a;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var closed_1 = this.closed;
+      _super.prototype.unsubscribe.call(this), !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 || _a.call(this));
+    }
+  }, OperatorSubscriber2;
+}(Subscriber), EmptyError = createErrorClass(function(_super) {
+  return function() {
+    _super(this), this.name = "EmptyError", this.message = "no elements in sequence";
+  };
+});
+function firstValueFrom(source, config2) {
+  var hasConfig = typeof config2 == "object";
+  return new Promise(function(resolve, reject) {
+    var subscriber = new SafeSubscriber({
+      next: function(value) {
+        resolve(value), subscriber.unsubscribe();
+      },
+      error: reject,
+      complete: function() {
+        hasConfig ? resolve(config2.defaultValue) : reject(new EmptyError());
+      }
+    });
+    source.subscribe(subscriber);
+  });
+}
+function filter(predicate, thisArg) {
+  return operate(function(source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      return predicate.call(thisArg, value, index++) && subscriber.next(value);
+    }));
+  });
+}
+const query = `*[_type == $translationSchema && $id in translations[].value._ref]{
   _id,
   _createdAt,
   translations
@@ -223,6 +609,129 @@ function useTranslationMetadata(id) {
   });
   return { data, loading, error };
 }
+const documenti18nLocaleNamespace = "document-internationalization", documentInternationalizationUsEnglishLocaleBundle = defineLocaleResourceBundle({
+  locale: "en-US",
+  namespace: documenti18nLocaleNamespace,
+  resources: () => import("./_legacy/resources.esm.js")
+}), DISABLED_REASON_KEY = {
+  METADATA_NOT_FOUND: "action.duplicate.disabled.missing-metadata",
+  MULTIPLE_METADATA: "action.duplicate.disabled.multiple-metadata",
+  NOTHING_TO_DUPLICATE: "action.duplicate.disabled.nothing-to-duplicate",
+  NOT_READY: "action.duplicate.disabled.not-ready"
+}, DuplicateWithTranslationsAction = ({
+  id,
+  type,
+  onComplete
+}) => {
+  const documentStore = useDocumentStore(), { duplicate } = useDocumentOperation(id, type), { navigateIntent } = useRouter(), [isDuplicating, setDuplicating] = useState(!1), [permissions, isPermissionsLoading] = useDocumentPairPermissions({
+    id,
+    type,
+    permission: "duplicate"
+  }), { data, loading: isMetadataDocumentLoading } = useTranslationMetadata(id), hasOneMetadataDocument = useMemo(() => Array.isArray(data) && data.length <= 1, [data]), metadataDocument = Array.isArray(data) && data.length ? data[0] : null, client = useClient(DEFAULT_STUDIO_CLIENT_OPTIONS), toast = useToast(), { t: s } = useTranslation(structureLocaleNamespace), { t: d } = useTranslation(documenti18nLocaleNamespace), currentUser = useCurrentUser(), handle = useCallback(async () => {
+    setDuplicating(!0);
+    try {
+      if (!metadataDocument)
+        throw new Error("Metadata document not found");
+      const translations = /* @__PURE__ */ new Map();
+      await Promise.all(
+        metadataDocument[TRANSLATIONS_ARRAY_NAME].map(async (translation) => {
+          var _a;
+          const dupeId2 = uuid(), locale = translation._key, docId = (_a = translation.value) == null ? void 0 : _a._ref;
+          if (!docId)
+            throw new Error("Translation document not found");
+          const { duplicate: duplicateTranslation } = await firstValueFrom(
+            documentStore.pair.editOperations(docId, type).pipe(filter((op) => op.duplicate.disabled !== "NOT_READY"))
+          );
+          if (duplicateTranslation.disabled)
+            throw new Error("Cannot duplicate document");
+          const duplicateTranslationSuccess = firstValueFrom(
+            documentStore.pair.operationEvents(docId, type).pipe(filter((e) => e.op === "duplicate" && e.type === "success"))
+          );
+          duplicateTranslation.execute(dupeId2), await duplicateTranslationSuccess, translations.set(locale, dupeId2);
+        })
+      );
+      const { duplicate: duplicateMetadata } = await firstValueFrom(
+        documentStore.pair.editOperations(metadataDocument._id, METADATA_SCHEMA_NAME).pipe(filter((op) => op.duplicate.disabled !== "NOT_READY"))
+      );
+      if (duplicateMetadata.disabled)
+        throw new Error("Cannot duplicate document");
+      const duplicateMetadataSuccess = firstValueFrom(
+        documentStore.pair.operationEvents(metadataDocument._id, METADATA_SCHEMA_NAME).pipe(filter((e) => e.op === "duplicate" && e.type === "success"))
+      ), dupeId = uuid();
+      duplicateMetadata.execute(dupeId), await duplicateMetadataSuccess;
+      const patch = {
+        set: Object.fromEntries(
+          Array.from(translations.entries()).map(([locale, documentId]) => [
+            `${TRANSLATIONS_ARRAY_NAME}[_key == "${locale}"].value._ref`,
+            documentId
+          ])
+        )
+      };
+      await client.transaction().patch(dupeId, patch).commit(), navigateIntent("edit", {
+        id: Array.from(translations.values()).at(0),
+        type
+      }), onComplete();
+    } catch (error) {
+      console.error(error), toast.push({
+        status: "error",
+        title: "Error duplicating document",
+        description: error instanceof Error ? error.message : "Failed to duplicate document"
+      });
+    } finally {
+      setDuplicating(!1);
+    }
+  }, [
+    client,
+    documentStore.pair,
+    metadataDocument,
+    navigateIntent,
+    onComplete,
+    toast,
+    type
+  ]);
+  return useMemo(() => !isPermissionsLoading && !(permissions != null && permissions.granted) ? {
+    icon: CopyIcon,
+    disabled: !0,
+    label: d("action.duplicate.label"),
+    title: /* @__PURE__ */ jsx(
+      InsufficientPermissionsMessage,
+      {
+        context: "duplicate-document",
+        currentUser
+      }
+    )
+  } : !isMetadataDocumentLoading && !metadataDocument ? {
+    icon: CopyIcon,
+    disabled: !0,
+    label: d("action.duplicate.label"),
+    title: d(DISABLED_REASON_KEY.METADATA_NOT_FOUND)
+  } : hasOneMetadataDocument ? {
+    icon: CopyIcon,
+    disabled: isDuplicating || !!duplicate.disabled || isPermissionsLoading || isMetadataDocumentLoading,
+    label: isDuplicating ? s("action.duplicate.running.label") : d("action.duplicate.label"),
+    title: duplicate.disabled ? s(DISABLED_REASON_KEY[duplicate.disabled]) : "",
+    onHandle: handle
+  } : {
+    icon: CopyIcon,
+    disabled: !0,
+    label: d("action.duplicate.label"),
+    title: d(DISABLED_REASON_KEY.MULTIPLE_METADATA)
+  }, [
+    currentUser,
+    duplicate.disabled,
+    handle,
+    hasOneMetadataDocument,
+    isDuplicating,
+    isMetadataDocumentLoading,
+    isPermissionsLoading,
+    metadataDocument,
+    permissions == null ? void 0 : permissions.granted,
+    s,
+    d
+  ]);
+};
+DuplicateWithTranslationsAction.action = "duplicate";
+DuplicateWithTranslationsAction.displayName = "DuplicateWithTranslationsAction";
 function useOpenInNewPane(id, type) {
   const routerContext = useContext(RouterContext), { routerPanesState, groupIndex } = usePaneRouter();
   return useCallback(() => {
@@ -243,42 +752,75 @@ function useOpenInNewPane(id, type) {
     routerContext.navigateUrl({ path: href });
   }, [id, type, routerContext, routerPanesState, groupIndex]);
 }
+function createReference(key, ref, type, strengthenOnPublish = !0) {
+  return {
+    _key: key,
+    _type: "internationalizedArrayReferenceValue",
+    value: {
+      _type: "reference",
+      _ref: ref,
+      _weak: !0,
+      // If the user has configured weakReferences, we won't want to strengthen them
+      ...strengthenOnPublish ? { _strengthenOnPublish: { type } } : {}
+    }
+  };
+}
 function LanguageManage(props) {
-  const { id } = props, open = useOpenInNewPane(id, METADATA_SCHEMA_NAME);
+  const { id, metadataId, schemaType, documentId, sourceLanguageId } = props, open = useOpenInNewPane(id, METADATA_SCHEMA_NAME), openCreated = useOpenInNewPane(metadataId, METADATA_SCHEMA_NAME), { allowCreateMetaDoc, apiVersion, weakReferences } = useDocumentInternationalizationContext(), client = useClient({ apiVersion }), [userHasClicked, setUserHasClicked] = useState(!1), canCreate = !id && !!metadataId && allowCreateMetaDoc, handleClick = useCallback(() => {
+    if (!id && metadataId && sourceLanguageId) {
+      setUserHasClicked(!0);
+      const transaction = client.transaction(), sourceReference = createReference(
+        sourceLanguageId,
+        documentId,
+        schemaType.name,
+        !weakReferences
+      ), newMetadataDocument = {
+        _id: metadataId,
+        _type: METADATA_SCHEMA_NAME,
+        schemaTypes: [schemaType.name],
+        translations: [sourceReference]
+      };
+      transaction.createIfNotExists(newMetadataDocument), transaction.commit().then(() => {
+        setUserHasClicked(!1), openCreated();
+      }).catch((err) => {
+        console.error(err), setUserHasClicked(!1);
+      });
+    } else
+      open();
+  }, [
+    id,
+    metadataId,
+    sourceLanguageId,
+    client,
+    documentId,
+    schemaType.name,
+    weakReferences,
+    openCreated,
+    open
+  ]);
   return /* @__PURE__ */ jsx(
     Tooltip,
     {
       animate: !0,
-      content: id ? null : /* @__PURE__ */ jsx(Box, { padding: 2, children: /* @__PURE__ */ jsx(Text, { muted: !0, size: 1, children: "Document has no other translations" }) }),
+      content: /* @__PURE__ */ jsx(Box, { padding: 2, children: /* @__PURE__ */ jsx(Text, { muted: !0, size: 1, children: "Document has no other translations" }) }),
       fallbackPlacements: ["right", "left"],
       placement: "top",
       portal: !0,
+      disabled: !!id || canCreate,
       children: /* @__PURE__ */ jsx(Stack, { children: /* @__PURE__ */ jsx(
         Button,
         {
-          disabled: !id,
+          disabled: !id && !canCreate || canCreate && !sourceLanguageId || userHasClicked,
           mode: "ghost",
           text: "Manage Translations",
           icon: CogIcon,
-          onClick: () => open()
+          loading: userHasClicked,
+          onClick: handleClick
         }
       ) })
     }
   );
 }
-function createReference(key, ref, type, strengthenOnPublish = !0) {
-  return {
-    _key: key,
-    _type: "internationalizedArrayReferenceValue",
-    value: {
-      _type: "reference",
-      _ref: ref,
-      _weak: !0,
-      // If the user has configured weakReferences, we won't want to strengthen them
-      ...strengthenOnPublish ? { _strengthenOnPublish: { type } } : {}
-    }
-  };
-}
 function removeExcludedPaths(doc, schemaType) {
   if (!isDocumentSchemaType(schemaType) || !doc)
     return doc;
@@ -496,7 +1038,16 @@ function DocumentInternationalizationMenu(props) {
       supportedLanguages
     ), valid;
   }, [supportedLanguages]), content = /* @__PURE__ */ jsx(Box, { padding: 1, children: error ? /* @__PURE__ */ jsx(Card, { tone: "critical", padding: 1, children: /* @__PURE__ */ jsx(Text, { children: "There was an error returning translations metadata" }) }) : /* @__PURE__ */ jsxs(Stack, { space: 1, children: [
-    /* @__PURE__ */ jsx(LanguageManage, { id: metadata2 == null ? void 0 : metadata2._id }),
+    /* @__PURE__ */ jsx(
+      LanguageManage,
+      {
+        id: metadata2 == null ? void 0 : metadata2._id,
+        documentId,
+        metadataId,
+        schemaType,
+        sourceLanguageId
+      }
+    ),
     supportedLanguages.length > 4 ? /* @__PURE__ */ jsx(
       TextInput,
       {
@@ -883,8 +1434,8 @@ var metadata = (schemaTypes, metadataFields) => defineType({
   }
 });
 const documentInternationalization = definePlugin(
-  (config) => {
-    const pluginConfig = { ...DEFAULT_CONFIG, ...config }, {
+  (config2) => {
+    const pluginConfig = { ...DEFAULT_CONFIG, ...config2 }, {
       supportedLanguages,
       schemaTypes,
       languageField,
@@ -902,6 +1453,9 @@ const documentInternationalization = definePlugin(
           layout: (props) => DocumentInternationalizationProvider({ ...props, pluginConfig })
         }
       },
+      i18n: {
+        bundles: [documentInternationalizationUsEnglishLocaleBundle]
+      },
       // Adds:
       // - A bulk-publishing UI component to the form
       // - Will only work for projects on a compatible plan
@@ -1042,6 +1596,7 @@ const documentInternationalization = definePlugin(
 export {
   DeleteTranslationAction,
   DocumentInternationalizationMenu,
+  DuplicateWithTranslationsAction,
   documentInternationalization,
   useDocumentInternationalizationContext
 };