@localazy/strapi-plugin 1.7.0 → 1.7.1

package/dist/server/src/functions/should-set-downloaded-property.d.ts

@@ -9,4 +9,23 @@ export declare enum ShouldSetDownloadedPropertyReturnType {
     NO = "no",
     JSON = "json"
 }
+/**
+ * Locate the field a downloaded key belongs to, using the Content Transfer Setup.
+ *
+ * - `YES`: the key is a plain field enabled for transfer (the field is the key's last segment).
+ * - `JSON`: the key is one leaf of an enabled `json` or `blocks` field, which the upload flattens
+ *   into one key per leaf; `fieldSegmentIndex` is the index in `parsedKeyRest` of the segment
+ *   naming that field. Everything before it is the path to the entry or component owning the
+ *   field (dynamic zone `id;component` segments and component ids included); everything after it
+ *   is the leaf's path inside the field's value, e.g. for
+ *   `beats[3;about.timeline].stops[10].notes[0].children[0].text` the field is `notes` (index 4)
+ *   of stop 10 of timeline 3, and for `tags[0]` or `years.2024` it is `tags` / `years` (index 0).
+ * - `NO`: anything else (field disabled or unknown, component gone, model not set up).
+ */
+export declare const locateDownloadedField: (modelContentTransferSetup: ModelContentTransferSetup, parsedKeyRest: string[]) => {
+    type: ShouldSetDownloadedPropertyReturnType;
+    fieldSegmentIndex: number;
+};
 export declare const shouldSetDownloadedProperty: (modelContentTransferSetup: ModelContentTransferSetup, parsedKeyRest: string[]) => ShouldSetDownloadedPropertyReturnType;
+/** Index of the `json`/`blocks` field's own segment in `parsedKeyRest`, or -1 (see `locateDownloadedField`). */
+export declare const getJsonFieldSegmentIndex: (modelContentTransferSetup: ModelContentTransferSetup, parsedKeyRest: string[]) => number;

package/dist/server/src/utils/align-localized-entry-to-source.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Downloaded values are positioned by the source-locale entry: the n-th repeatable component or
+ * dynamic zone item of the source goes to the n-th item of the localization. That holds only while
+ * both lists have the same layout. When the source list was changed (items added or removed,
+ * dynamic zone components replaced or reordered), the localized list is rebuilt from the source
+ * items instead of merging translations into unrelated items.
+ *
+ * Only lists that receive downloaded values (present in `downloadedEntry`) are aligned; other
+ * localized values are kept as they are.
+ */
+export declare const alignLocalizedEntryToSource: (models: any, localizedEntry: any, sourceEntry: any, model: any, downloadedEntry: any) => any;

package/dist/server/src/utils/build-localized-create-entry.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Data for creating a new localization of `baseEntry` (the source-locale entry) from the
+ * translated model downloaded from Localazy: the source entry with the translated values put in
+ * place. Items positioning is done by `parsedLocalazyEntryToCreateEntry`, so the two can be merged.
+ */
+export declare const buildLocalizedCreateEntry: (models: any, translatedModel: any, baseEntry: any, uid: any, isoStrapi: string) => Record<string, any>;

package/dist/server/src/utils/collect-downloaded-content.d.ts

@@ -0,0 +1,44 @@
+export type DownloadedLocalazyKey = {
+    id: string;
+    key: string[];
+    value: unknown;
+    event?: number;
+};
+export type DownloadedKeySource = {
+    lang: string;
+    id: string;
+    event: number | undefined;
+};
+/** `{ [isoStrapi]: { [uid]: { [documentId]: translatedModel } } }` */
+export type ParsedLocalazyContent = Record<string, Record<string, Record<string, any>>>;
+type ParseLocalazyKey = (key: string) => {
+    uid: string;
+    id: string;
+    rest: string[];
+};
+/**
+ * Turns the keys downloaded from Localazy into one translated model per Strapi entry and locale,
+ * and records which keys changed for each entry (so they can be marked processed once the entry
+ * is written).
+ *
+ * With a sync cursor (`processedKeys`), only entries with at least one key changed since it was
+ * last processed are taken, but each of them with all of its keys: an incremental download
+ * rewrites a changed entry exactly as a full sync would. Applying the changed keys alone is not
+ * enough, because a json/blocks field is rebuilt from all of its leaves and list items are placed
+ * by the source entry, so a partial set of keys would put source-language text or wrong items into
+ * everything that did not change.
+ */
+export declare const collectDownloadedContent: ({ languages, processedKeys, contentTransferSetup, models, parseLocalazyKey, }: {
+    languages: Array<{
+        isoStrapi: string;
+        keys: DownloadedLocalazyKey[];
+    }>;
+    processedKeys: Record<string, Record<string, number>>;
+    contentTransferSetup: any;
+    models: any[];
+    parseLocalazyKey: ParseLocalazyKey;
+}) => {
+    parsedLocalazyContent: ParsedLocalazyContent;
+    entryKeySourceMap: Record<string, DownloadedKeySource[]>;
+};
+export {};

package/dist/server/src/utils/json-fields-download-accumulator.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Collects the downloaded keys of `json` and `blocks` fields. On upload such a field is flattened
+ * into one Localazy key per leaf; on download the leaves are put back together into one value per
+ * field, which is then written into the parsed Localazy content at the field's own path.
+ *
+ * A field is identified by its full path (owner path + field name), so two json/blocks fields of
+ * the same entry or component (e.g. a component's `title` and `line`) never share one value, and
+ * a field inside a nested component is written at its own level instead of replacing the
+ * component it lives in.
+ */
+export declare const createJsonFieldsDownloadAccumulator: () => {
+    /**
+     * @param fieldKey path to the field in the parsed content: `[iso, uid, documentId, ...ownerPath, fieldName]`
+     * @param valuePath path of this leaf inside the field's value
+     */
+    add(fieldKey: string[], valuePath: string[], value: unknown): void;
+    /** Write every collected field value into `parsedContent` at its own path. */
+    applyTo(parsedContent: Record<string, any>): void;
+};

package/dist/server/src/utils/model-utils.d.ts

@@ -4,5 +4,6 @@ declare const isDynamicZone: (attributeObj: any) => boolean;
 declare const isRepeatable: (attributeObj: any) => boolean;
 declare const isRelation: (attributeObj: any) => boolean;
 declare const isBlocks: (attributeObj: any) => boolean;
+declare const isJson: (attributeObj: any) => boolean;
 declare const findModel: (models: any, uid: any) => any;
-export { getAttribute, isComponent, isDynamicZone, isRepeatable, isRelation, isBlocks, findModel };
+export { getAttribute, isComponent, isDynamicZone, isRepeatable, isRelation, isBlocks, isJson, findModel };

package/dist/server/src/utils/overlay-json-translation.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Download side of a `json` field. On upload, every leaf of the source-locale value becomes one
+ * Localazy key (see `flattenObject`); `translated` is those leaves put back together by key path.
+ * The result is a copy of the source value with each string leaf replaced by its translation, so
+ * its shape (objects vs arrays, numeric keys, non-string values) always matches the source, leaves
+ * that are no longer in the source are ignored, and untranslated leaves keep the source text.
+ *
+ * Returns `undefined` when there is no source value to overlay onto.
+ */
+export declare const overlayJsonTranslation: (sourceValue: any, translated: any) => any;

package/dist/server/src/utils/parse-localazy-key.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Split a Localazy key produced by the upload (`flattenObject`) into the content type uid, the
+ * document id and the remaining path segments, e.g.
+ * `api::page.page[doc].sections[3;sections.timeline].stops[11].label` →
+ * `{ uid: 'api::page.page', id: 'doc', rest: ['sections', '3;sections.timeline', 'stops', '11', 'label'] }`.
+ */
+export declare const parseLocalazyKey: (key: string) => {
+    uid: string;
+    id: string;
+    rest: string[];
+};

package/dist/server/src/utils/parsed-localazy-entry-to-create-entry.d.ts

@@ -1,7 +1,15 @@
 /**
- * Items positioning is done by the `toCreateEntry` function
+ * Items positioning is done by the `toCreateEntry` function: repeatable component and dynamic
+ * zone items are placed at their position in `baseEntry` (the source-locale entry), so arrays may
+ * have holes for items without downloaded values. They are not compacted, because callers merge
+ * the result onto a complete entry (the source entry, or the current localization), and shifting
+ * items would put translations into the wrong item.
+ *
+ * `rebuiltFieldPaths` lists where blocks and json fields were written; each holds a complete value
+ * rebuilt from the source value (see `overlayBlocksTranslation`, `overlayJsonTranslation`).
  */
 export declare const parsedLocalazyEntryToCreateEntry: (models: any, parsedLocalazyEntry: any, baseEntry: any, uid: string, locale?: string) => {
     createEntry: Record<string, any>;
     dynamicZoneComponentKeys: any[];
+    rebuiltFieldPaths: string[];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@localazy/strapi-plugin",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "The official Strapi Plugin by Localazy.",
   "keywords": [
     "strapi",

package/dist/server/src/utils/reset-array-keys-deep.d.ts

@@ -1 +0,0 @@
-export declare const resetArrayKeysDeep: (object: Record<string, any>, keysToFilter: string[]) => void;