[Summary view] [Print] [Text view]

   1  var wp;
   2  (wp ||= {}).annotations = (() => {
   3    var __create = Object.create;
   4    var __defProp = Object.defineProperty;
   5    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   6    var __getOwnPropNames = Object.getOwnPropertyNames;
   7    var __getProtoOf = Object.getPrototypeOf;
   8    var __hasOwnProp = Object.prototype.hasOwnProperty;
   9    var __commonJS = (cb, mod) => function __require() {
  10      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  11    };
  12    var __export = (target, all) => {
  13      for (var name2 in all)
  14        __defProp(target, name2, { get: all[name2], enumerable: true });
  15    };
  16    var __copyProps = (to, from, except, desc) => {
  17      if (from && typeof from === "object" || typeof from === "function") {
  18        for (let key of __getOwnPropNames(from))
  19          if (!__hasOwnProp.call(to, key) && key !== except)
  20            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  21      }
  22      return to;
  23    };
  24    var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  25      // If the importer is in node compatibility mode or this is not an ESM
  26      // file that has been converted to a CommonJS file using a Babel-
  27      // compatible transform (i.e. "__esModule" has not been set), then set
  28      // "default" to the CommonJS "module.exports" for node compatibility.
  29      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  30      mod
  31    ));
  32    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  33  
  34    // package-external:@wordpress/rich-text
  35    var require_rich_text = __commonJS({
  36      "package-external:@wordpress/rich-text"(exports, module) {
  37        module.exports = window.wp.richText;
  38      }
  39    });
  40  
  41    // package-external:@wordpress/i18n
  42    var require_i18n = __commonJS({
  43      "package-external:@wordpress/i18n"(exports, module) {
  44        module.exports = window.wp.i18n;
  45      }
  46    });
  47  
  48    // package-external:@wordpress/hooks
  49    var require_hooks = __commonJS({
  50      "package-external:@wordpress/hooks"(exports, module) {
  51        module.exports = window.wp.hooks;
  52      }
  53    });
  54  
  55    // package-external:@wordpress/data
  56    var require_data = __commonJS({
  57      "package-external:@wordpress/data"(exports, module) {
  58        module.exports = window.wp.data;
  59      }
  60    });
  61  
  62    // packages/annotations/build-module/index.js
  63    var index_exports = {};
  64    __export(index_exports, {
  65      store: () => store
  66    });
  67  
  68    // packages/annotations/build-module/format/index.js
  69    var import_rich_text2 = __toESM(require_rich_text());
  70  
  71    // packages/annotations/build-module/format/annotation.js
  72    var import_i18n = __toESM(require_i18n());
  73    var import_rich_text = __toESM(require_rich_text());
  74  
  75    // packages/annotations/build-module/store/constants.js
  76    var STORE_NAME = "core/annotations";
  77  
  78    // packages/annotations/build-module/format/annotation.js
  79    var FORMAT_NAME = "core/annotation";
  80    var ANNOTATION_ATTRIBUTE_PREFIX = "annotation-text-";
  81    function applyAnnotations(record, annotations2 = []) {
  82      annotations2.forEach((annotation2) => {
  83        let { start, end } = annotation2;
  84        if (start > record.text.length) {
  85          start = record.text.length;
  86        }
  87        if (end > record.text.length) {
  88          end = record.text.length;
  89        }
  90        const className = ANNOTATION_ATTRIBUTE_PREFIX + annotation2.source;
  91        const id = ANNOTATION_ATTRIBUTE_PREFIX + annotation2.id;
  92        record = (0, import_rich_text.applyFormat)(
  93          record,
  94          {
  95            type: FORMAT_NAME,
  96            attributes: {
  97              className,
  98              id
  99            }
 100          },
 101          start,
 102          end
 103        );
 104      });
 105      return record;
 106    }
 107    function retrieveAnnotationPositions(formats) {
 108      const positions = {};
 109      formats.forEach((characterFormats, i) => {
 110        characterFormats = characterFormats || [];
 111        characterFormats = characterFormats.filter(
 112          (format) => format.type === FORMAT_NAME
 113        );
 114        characterFormats.forEach((format) => {
 115          let { id } = format.attributes;
 116          id = id.replace(ANNOTATION_ATTRIBUTE_PREFIX, "");
 117          if (!positions.hasOwnProperty(id)) {
 118            positions[id] = {
 119              start: i
 120            };
 121          }
 122          positions[id].end = i + 1;
 123        });
 124      });
 125      return positions;
 126    }
 127    function updateAnnotationsWithPositions(annotations2, positions, { removeAnnotation, updateAnnotationRange }) {
 128      annotations2.forEach((currentAnnotation) => {
 129        const position = positions[currentAnnotation.id];
 130        if (!position) {
 131          removeAnnotation(currentAnnotation.id);
 132          return;
 133        }
 134        const { start, end } = currentAnnotation;
 135        if (start !== position.start || end !== position.end) {
 136          updateAnnotationRange(
 137            currentAnnotation.id,
 138            position.start,
 139            position.end
 140          );
 141        }
 142      });
 143    }
 144    var annotation = {
 145      name: FORMAT_NAME,
 146      title: (0, import_i18n.__)("Annotation"),
 147      tagName: "mark",
 148      className: "annotation-text",
 149      attributes: {
 150        className: "class",
 151        id: "id"
 152      },
 153      edit() {
 154        return null;
 155      },
 156      __experimentalGetPropsForEditableTreePreparation(select, { richTextIdentifier, blockClientId }) {
 157        return {
 158          annotations: select(
 159            STORE_NAME
 160          ).__experimentalGetAnnotationsForRichText(
 161            blockClientId,
 162            richTextIdentifier
 163          )
 164        };
 165      },
 166      __experimentalCreatePrepareEditableTree({ annotations: annotations2 }) {
 167        return (formats, text) => {
 168          if (annotations2.length === 0) {
 169            return formats;
 170          }
 171          let record = { formats, text };
 172          record = applyAnnotations(record, annotations2);
 173          return record.formats;
 174        };
 175      },
 176      __experimentalGetPropsForEditableTreeChangeHandler(dispatch) {
 177        return {
 178          removeAnnotation: dispatch(STORE_NAME).__experimentalRemoveAnnotation,
 179          updateAnnotationRange: dispatch(STORE_NAME).__experimentalUpdateAnnotationRange
 180        };
 181      },
 182      __experimentalCreateOnChangeEditableValue(props) {
 183        return (formats) => {
 184          const positions = retrieveAnnotationPositions(formats);
 185          const { removeAnnotation, updateAnnotationRange, annotations: annotations2 } = props;
 186          updateAnnotationsWithPositions(annotations2, positions, {
 187            removeAnnotation,
 188            updateAnnotationRange
 189          });
 190        };
 191      }
 192    };
 193  
 194    // packages/annotations/build-module/format/index.js
 195    var { name, ...settings } = annotation;
 196    (0, import_rich_text2.registerFormatType)(name, settings);
 197  
 198    // packages/annotations/build-module/block/index.js
 199    var import_hooks = __toESM(require_hooks());
 200    var import_data = __toESM(require_data());
 201    var addAnnotationClassName = (OriginalComponent) => {
 202      return (0, import_data.withSelect)((select, { clientId, className }) => {
 203        const annotations2 = select(STORE_NAME).__experimentalGetAnnotationsForBlock(
 204          clientId
 205        );
 206        return {
 207          className: annotations2.map((annotation2) => {
 208            return "is-annotated-by-" + annotation2.source;
 209          }).concat(className).filter(Boolean).join(" ")
 210        };
 211      })(OriginalComponent);
 212    };
 213    (0, import_hooks.addFilter)(
 214      "editor.BlockListBlock",
 215      "core/annotations",
 216      addAnnotationClassName
 217    );
 218  
 219    // packages/annotations/build-module/store/index.js
 220    var import_data3 = __toESM(require_data());
 221  
 222    // packages/annotations/build-module/store/reducer.js
 223    function filterWithReference(collection, predicate) {
 224      const filteredCollection = collection.filter(predicate);
 225      return collection.length === filteredCollection.length ? collection : filteredCollection;
 226    }
 227    var mapValues = (obj, callback) => Object.entries(obj).reduce(
 228      (acc, [key, value]) => ({
 229        ...acc,
 230        [key]: callback(value)
 231      }),
 232      {}
 233    );
 234    function isValidAnnotationRange(annotation2) {
 235      return typeof annotation2.start === "number" && typeof annotation2.end === "number" && annotation2.start <= annotation2.end;
 236    }
 237    function annotations(state = {}, action) {
 238      switch (action.type) {
 239        case "ANNOTATION_ADD":
 240          const blockClientId = action.blockClientId;
 241          const newAnnotation = {
 242            id: action.id,
 243            blockClientId,
 244            richTextIdentifier: action.richTextIdentifier,
 245            source: action.source,
 246            selector: action.selector,
 247            range: action.range
 248          };
 249          if (newAnnotation.selector === "range" && !isValidAnnotationRange(newAnnotation.range)) {
 250            return state;
 251          }
 252          const previousAnnotationsForBlock = state?.[blockClientId] ?? [];
 253          return {
 254            ...state,
 255            [blockClientId]: [
 256              ...previousAnnotationsForBlock,
 257              newAnnotation
 258            ]
 259          };
 260        case "ANNOTATION_REMOVE":
 261          return mapValues(state, (annotationsForBlock) => {
 262            return filterWithReference(
 263              annotationsForBlock,
 264              (annotation2) => {
 265                return annotation2.id !== action.annotationId;
 266              }
 267            );
 268          });
 269        case "ANNOTATION_UPDATE_RANGE":
 270          return mapValues(state, (annotationsForBlock) => {
 271            let hasChangedRange = false;
 272            const newAnnotations = annotationsForBlock.map(
 273              (annotation2) => {
 274                if (annotation2.id === action.annotationId) {
 275                  hasChangedRange = true;
 276                  return {
 277                    ...annotation2,
 278                    range: {
 279                      start: action.start,
 280                      end: action.end
 281                    }
 282                  };
 283                }
 284                return annotation2;
 285              }
 286            );
 287            return hasChangedRange ? newAnnotations : annotationsForBlock;
 288          });
 289        case "ANNOTATION_REMOVE_SOURCE":
 290          return mapValues(state, (annotationsForBlock) => {
 291            return filterWithReference(
 292              annotationsForBlock,
 293              (annotation2) => {
 294                return annotation2.source !== action.source;
 295              }
 296            );
 297          });
 298      }
 299      return state;
 300    }
 301    var reducer_default = annotations;
 302  
 303    // packages/annotations/build-module/store/selectors.js
 304    var selectors_exports = {};
 305    __export(selectors_exports, {
 306      __experimentalGetAllAnnotationsForBlock: () => __experimentalGetAllAnnotationsForBlock,
 307      __experimentalGetAnnotations: () => __experimentalGetAnnotations,
 308      __experimentalGetAnnotationsForBlock: () => __experimentalGetAnnotationsForBlock,
 309      __experimentalGetAnnotationsForRichText: () => __experimentalGetAnnotationsForRichText
 310    });
 311    var import_data2 = __toESM(require_data());
 312    var EMPTY_ARRAY = [];
 313    var __experimentalGetAnnotationsForBlock = (0, import_data2.createSelector)(
 314      (state, blockClientId) => {
 315        return (state?.[blockClientId] ?? []).filter((annotation2) => {
 316          return annotation2.selector === "block";
 317        });
 318      },
 319      (state, blockClientId) => [state?.[blockClientId] ?? EMPTY_ARRAY]
 320    );
 321    function __experimentalGetAllAnnotationsForBlock(state, blockClientId) {
 322      return state?.[blockClientId] ?? EMPTY_ARRAY;
 323    }
 324    var __experimentalGetAnnotationsForRichText = (0, import_data2.createSelector)(
 325      (state, blockClientId, richTextIdentifier) => {
 326        return (state?.[blockClientId] ?? []).filter((annotation2) => {
 327          return annotation2.selector === "range" && richTextIdentifier === annotation2.richTextIdentifier;
 328        }).map((annotation2) => {
 329          const { range, ...other } = annotation2;
 330          return {
 331            ...range,
 332            ...other
 333          };
 334        });
 335      },
 336      (state, blockClientId) => [state?.[blockClientId] ?? EMPTY_ARRAY]
 337    );
 338    function __experimentalGetAnnotations(state) {
 339      return Object.values(state).flat();
 340    }
 341  
 342    // packages/annotations/build-module/store/actions.js
 343    var actions_exports = {};
 344    __export(actions_exports, {
 345      __experimentalAddAnnotation: () => __experimentalAddAnnotation,
 346      __experimentalRemoveAnnotation: () => __experimentalRemoveAnnotation,
 347      __experimentalRemoveAnnotationsBySource: () => __experimentalRemoveAnnotationsBySource,
 348      __experimentalUpdateAnnotationRange: () => __experimentalUpdateAnnotationRange
 349    });
 350  
 351    // node_modules/uuid/dist/esm-browser/rng.js
 352    var getRandomValues;
 353    var rnds8 = new Uint8Array(16);
 354    function rng() {
 355      if (!getRandomValues) {
 356        getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
 357        if (!getRandomValues) {
 358          throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
 359        }
 360      }
 361      return getRandomValues(rnds8);
 362    }
 363  
 364    // node_modules/uuid/dist/esm-browser/stringify.js
 365    var byteToHex = [];
 366    for (let i = 0; i < 256; ++i) {
 367      byteToHex.push((i + 256).toString(16).slice(1));
 368    }
 369    function unsafeStringify(arr, offset = 0) {
 370      return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
 371    }
 372  
 373    // node_modules/uuid/dist/esm-browser/native.js
 374    var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
 375    var native_default = {
 376      randomUUID
 377    };
 378  
 379    // node_modules/uuid/dist/esm-browser/v4.js
 380    function v4(options, buf, offset) {
 381      if (native_default.randomUUID && !buf && !options) {
 382        return native_default.randomUUID();
 383      }
 384      options = options || {};
 385      const rnds = options.random || (options.rng || rng)();
 386      rnds[6] = rnds[6] & 15 | 64;
 387      rnds[8] = rnds[8] & 63 | 128;
 388      if (buf) {
 389        offset = offset || 0;
 390        for (let i = 0; i < 16; ++i) {
 391          buf[offset + i] = rnds[i];
 392        }
 393        return buf;
 394      }
 395      return unsafeStringify(rnds);
 396    }
 397    var v4_default = v4;
 398  
 399    // packages/annotations/build-module/store/actions.js
 400    function __experimentalAddAnnotation({
 401      blockClientId,
 402      richTextIdentifier = null,
 403      range = null,
 404      selector = "range",
 405      source = "default",
 406      id = v4_default()
 407    }) {
 408      const action = {
 409        type: "ANNOTATION_ADD",
 410        id,
 411        blockClientId,
 412        richTextIdentifier,
 413        source,
 414        selector
 415      };
 416      if (selector === "range") {
 417        action.range = range;
 418      }
 419      return action;
 420    }
 421    function __experimentalRemoveAnnotation(annotationId) {
 422      return {
 423        type: "ANNOTATION_REMOVE",
 424        annotationId
 425      };
 426    }
 427    function __experimentalUpdateAnnotationRange(annotationId, start, end) {
 428      return {
 429        type: "ANNOTATION_UPDATE_RANGE",
 430        annotationId,
 431        start,
 432        end
 433      };
 434    }
 435    function __experimentalRemoveAnnotationsBySource(source) {
 436      return {
 437        type: "ANNOTATION_REMOVE_SOURCE",
 438        source
 439      };
 440    }
 441  
 442    // packages/annotations/build-module/store/index.js
 443    var store = (0, import_data3.createReduxStore)(STORE_NAME, {
 444      reducer: reducer_default,
 445      selectors: selectors_exports,
 446      actions: actions_exports
 447    });
 448    (0, import_data3.register)(store);
 449    return __toCommonJS(index_exports);
 450  })();