@intlayer/core/dist/cjs/interpreter/getContent/plugins.cjs

Includes core Intlayer functions like translation, dictionary, and utility functions shared across multiple packages.

"use strict";
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);
var plugins_exports = {};
__export(plugins_exports, {
  conditionPlugin: () => conditionPlugin,
  enumerationPlugin: () => enumerationPlugin,
  filePlugin: () => filePlugin,
  insertionPlugin: () => insertionPlugin,
  nestedPlugin: () => nestedPlugin,
  translationPlugin: () => translationPlugin
});
module.exports = __toCommonJS(plugins_exports);
var import_types = require('../../types/index.cjs');
var import_getCondition = require('../getCondition.cjs');
var import_getEnumeration = require('../getEnumeration.cjs');
var import_getInsertion = require('../getInsertion.cjs');
var import_getNesting = require('../getNesting.cjs');
var import_getTranslation = require('../getTranslation.cjs');
const translationPlugin = (locale, fallback = true) => ({
  id: "translation-plugin",
  canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Translation,
  transform: (node, props, deepTransformNode) => {
    const result = structuredClone(node[import_types.NodeType.Translation]);
    for (const key in result) {
      const childProps = {
        ...props,
        children: result[key],
        keyPath: [
          ...props.keyPath,
          { type: import_types.NodeType.Translation, key }
        ]
      };
      result[key] = deepTransformNode(
        result[key],
        childProps
      );
    }
    return (0, import_getTranslation.getTranslation)(result, locale, fallback);
  }
});
const enumerationPlugin = {
  id: "enumeration-plugin",
  canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Enumeration,
  transform: (node, props, deepTransformNode) => {
    const result = structuredClone(node[import_types.NodeType.Enumeration]);
    for (const key in result) {
      const child = result[key];
      const childProps = {
        ...props,
        children: child,
        keyPath: [
          ...props.keyPath,
          { type: import_types.NodeType.Enumeration, key }
        ]
      };
      result[key] = deepTransformNode(
        child,
        childProps
      );
    }
    return (quantity) => (0, import_getEnumeration.getEnumeration)(result, quantity);
  }
};
const conditionPlugin = {
  id: "condition-plugin",
  canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Condition,
  transform: (node, props, deepTransformNode) => {
    const result = structuredClone(node[import_types.NodeType.Condition]);
    for (const key in result) {
      const child = result[key];
      const childProps = {
        ...props,
        children: child,
        keyPath: [
          ...props.keyPath,
          { type: import_types.NodeType.Condition, key }
        ]
      };
      result[key] = deepTransformNode(
        child,
        childProps
      );
    }
    return (value) => (0, import_getCondition.getCondition)(result, value);
  }
};
const insertionPlugin = {
  id: "insertion-plugin",
  canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Insertion,
  transform: (node, props, deepTransformNode) => {
    const newKeyPath = [
      ...props.keyPath,
      {
        type: import_types.NodeType.Insertion
      }
    ];
    const children = node[import_types.NodeType.Insertion];
    const insertionStringPlugin = {
      id: "insertion-string-plugin",
      canHandle: (node2) => typeof node2 === "string",
      transform: (node2, subProps, deepTransformNode2) => {
        const transformedResult = deepTransformNode2(node2, {
          ...subProps,
          children: node2,
          plugins: [
            ...(props.plugins ?? []).filter(
              (plugin) => plugin.id !== "intlayer-node-plugin"
            )
          ]
        });
        return (values) => {
          const children2 = (0, import_getInsertion.getInsertion)(transformedResult, values);
          return deepTransformNode2(children2, {
            ...subProps,
            plugins: props.plugins,
            children: children2
          });
        };
      }
    };
    return deepTransformNode(children, {
      ...props,
      children,
      keyPath: newKeyPath,
      plugins: [insertionStringPlugin, ...props.plugins ?? []]
    });
  }
};
const nestedPlugin = {
  id: "nested-plugin",
  canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.Nested,
  transform: (node, props) => (0, import_getNesting.getNesting)(node.nested.dictionaryKey, node.nested.path, props)
};
const filePlugin = {
  id: "file-plugin",
  canHandle: (node) => typeof node === "object" && node?.nodeType === import_types.NodeType.File,
  transform: (node, props, deepTransform) => deepTransform(node.content, {
    ...props,
    children: node.content
  })
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  conditionPlugin,
  enumerationPlugin,
  filePlugin,
  insertionPlugin,
  nestedPlugin,
  translationPlugin
});
//# sourceMappingURL=plugins.cjs.map