@wordpress/blocks/build/api/parser/index.js

Block API for WordPress.

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// packages/blocks/src/api/parser/index.js
var parser_exports = {};
__export(parser_exports, {
  default: () => parse,
  normalizeRawBlock: () => normalizeRawBlock,
  parseRawBlock: () => parseRawBlock
});
module.exports = __toCommonJS(parser_exports);
var import_block_serialization_default_parser = require("@wordpress/block-serialization-default-parser");
var import_autop = require("@wordpress/autop");
var import_registration = require("../registration");
var import_serializer = require("../serializer");
var import_validation = require("../validation");
var import_factory = require("../factory");
var import_convert_legacy_block = require("./convert-legacy-block");
var import_serialize_raw_block = require("./serialize-raw-block");
var import_get_block_attributes = require("./get-block-attributes");
var import_apply_block_deprecated_versions = require("./apply-block-deprecated-versions");
var import_apply_built_in_validation_fixes = require("./apply-built-in-validation-fixes");
function convertLegacyBlocks(rawBlock) {
  const [correctName, correctedAttributes] = (0, import_convert_legacy_block.convertLegacyBlockNameAndAttributes)(
    rawBlock.blockName,
    rawBlock.attrs
  );
  return {
    ...rawBlock,
    blockName: correctName,
    attrs: correctedAttributes
  };
}
function normalizeRawBlock(rawBlock, options) {
  const fallbackBlockName = (0, import_registration.getFreeformContentHandlerName)();
  const rawBlockName = rawBlock.blockName || (0, import_registration.getFreeformContentHandlerName)();
  const rawAttributes = rawBlock.attrs || {};
  const rawInnerBlocks = rawBlock.innerBlocks || [];
  let rawInnerHTML = rawBlock.innerHTML.trim();
  if (rawBlockName === fallbackBlockName && rawBlockName === "core/freeform" && !options?.__unstableSkipAutop) {
    rawInnerHTML = (0, import_autop.autop)(rawInnerHTML).trim();
  }
  return {
    ...rawBlock,
    blockName: rawBlockName,
    attrs: rawAttributes,
    innerHTML: rawInnerHTML,
    innerBlocks: rawInnerBlocks
  };
}
function createMissingBlockType(rawBlock) {
  const unregisteredFallbackBlock = (0, import_registration.getUnregisteredTypeHandlerName)() || (0, import_registration.getFreeformContentHandlerName)();
  const originalUndelimitedContent = (0, import_serialize_raw_block.serializeRawBlock)(rawBlock, {
    isCommentDelimited: false
  });
  const originalContent = (0, import_serialize_raw_block.serializeRawBlock)(rawBlock, {
    isCommentDelimited: true
  });
  return {
    blockName: unregisteredFallbackBlock,
    attrs: {
      originalName: rawBlock.blockName,
      originalContent,
      originalUndelimitedContent
    },
    innerHTML: rawBlock.blockName ? originalContent : rawBlock.innerHTML,
    innerBlocks: rawBlock.innerBlocks,
    innerContent: rawBlock.innerContent
  };
}
function applyBlockValidation(unvalidatedBlock, blockType) {
  const [isValid] = (0, import_validation.validateBlock)(unvalidatedBlock, blockType);
  if (isValid) {
    return { ...unvalidatedBlock, isValid, validationIssues: [] };
  }
  const fixedBlock = (0, import_apply_built_in_validation_fixes.applyBuiltInValidationFixes)(
    unvalidatedBlock,
    blockType
  );
  const [isFixedValid, validationIssues] = (0, import_validation.validateBlock)(
    fixedBlock,
    blockType
  );
  return { ...fixedBlock, isValid: isFixedValid, validationIssues };
}
function parseRawBlock(rawBlock, options) {
  let normalizedBlock = normalizeRawBlock(rawBlock, options);
  normalizedBlock = convertLegacyBlocks(normalizedBlock);
  let blockType = (0, import_registration.getBlockType)(normalizedBlock.blockName);
  if (!blockType) {
    normalizedBlock = createMissingBlockType(normalizedBlock);
    blockType = (0, import_registration.getBlockType)(normalizedBlock.blockName);
  }
  const isFallbackBlock = normalizedBlock.blockName === (0, import_registration.getFreeformContentHandlerName)() || normalizedBlock.blockName === (0, import_registration.getUnregisteredTypeHandlerName)();
  if (!blockType || !normalizedBlock.innerHTML && isFallbackBlock) {
    return;
  }
  const parsedInnerBlocks = normalizedBlock.innerBlocks.map((innerBlock) => parseRawBlock(innerBlock, options)).filter((innerBlock) => !!innerBlock);
  const parsedBlock = (0, import_factory.createBlock)(
    normalizedBlock.blockName,
    (0, import_get_block_attributes.getBlockAttributes)(
      blockType,
      normalizedBlock.innerHTML,
      normalizedBlock.attrs
    ),
    parsedInnerBlocks
  );
  parsedBlock.originalContent = normalizedBlock.innerHTML;
  const validatedBlock = applyBlockValidation(parsedBlock, blockType);
  const { validationIssues } = validatedBlock;
  const updatedBlock = (0, import_apply_block_deprecated_versions.applyBlockDeprecatedVersions)(
    validatedBlock,
    normalizedBlock,
    blockType
  );
  if (!updatedBlock.isValid) {
    updatedBlock.__unstableBlockSource = rawBlock;
  }
  if (!validatedBlock.isValid && updatedBlock.isValid && !options?.__unstableSkipMigrationLogs) {
    console.groupCollapsed("Updated Block: %s", blockType.name);
    console.info(
      "Block successfully updated for `%s` (%o).\n\nNew content generated by `save` function:\n\n%s\n\nContent retrieved from post body:\n\n%s",
      blockType.name,
      blockType,
      (0, import_serializer.getSaveContent)(blockType, updatedBlock.attributes),
      updatedBlock.originalContent
    );
    console.groupEnd();
  } else if (!validatedBlock.isValid && !updatedBlock.isValid) {
    validationIssues.forEach(({ log, args }) => log(...args));
  }
  return updatedBlock;
}
function parse(content, options) {
  return (0, import_block_serialization_default_parser.parse)(content).reduce((accumulator, rawBlock) => {
    const block = parseRawBlock(rawBlock, options);
    if (block) {
      accumulator.push(block);
    }
    return accumulator;
  }, []);
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  normalizeRawBlock,
  parseRawBlock
});
//# sourceMappingURL=index.js.map