@salesforce-ux/eslint-plugin-slds/build/utils/node.js

ESLint plugin provides custom linting rules specifically built for Salesforce Lightning Design System 2 (SLDS 2 beta)

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);

// src/utils/node.ts
var node_exports = {};
__export(node_exports, {
  codeToLines: () => codeToLines,
  findAttr: () => findAttr,
  getLocBetween: () => getLocBetween,
  getTemplateTokens: () => getTemplateTokens,
  isAttributesEmpty: () => isAttributesEmpty,
  isComment: () => isComment,
  isExpressionInTemplate: () => isExpressionInTemplate,
  isNodeTokensOnSameLine: () => isNodeTokensOnSameLine,
  isOverlapWithTemplates: () => isOverlapWithTemplates,
  isRangesOverlap: () => isRangesOverlap,
  isTag: () => isTag,
  isText: () => isText,
  splitToLineNodes: () => splitToLineNodes
});
module.exports = __toCommonJS(node_exports);
var import_parser = require("@html-eslint/parser");
function findAttr(node, key) {
  return node.attributes.find(
    (attr) => attr.key && attr.key.value.toLowerCase() === key.toLowerCase()
  );
}
function isAttributesEmpty(node) {
  return !node.attributes || node.attributes.length <= 0;
}
function isNodeTokensOnSameLine(node) {
  return node.loc.start.line === node.loc.end.line;
}
function isRangesOverlap(rangeA, rangeB) {
  return rangeA[0] < rangeB[1] && rangeB[0] < rangeA[1];
}
function isOverlapWithTemplates(templates, range) {
  return templates.filter((template) => template.isTemplate).some((template) => isRangesOverlap(template.range, range));
}
function splitToLineNodes(node) {
  let start = node.range[0];
  let line = node.loc.start.line;
  const startCol = node.loc.start.column;
  const lineNodes = [];
  const templates = node.templates || [];
  function shouldSkipIndentCheck(range) {
    const overlappedTemplates = templates.filter(
      (template) => template.isTemplate && isRangesOverlap(template.range, range)
    );
    const isLineInTemplate = overlappedTemplates.some((template) => {
      return template.range[0] <= range[0] && template.range[1] >= range[1];
    });
    if (isLineInTemplate) {
      return true;
    }
    const isLineBeforeTemplate = overlappedTemplates.some((template) => {
      return template.range[0] <= range[0] && template.range[1] <= range[1];
    });
    if (isLineBeforeTemplate) {
      return true;
    }
    const isLineAfterTemplate = overlappedTemplates.some((template) => {
      return template.range[1] <= range[0];
    });
    if (isLineAfterTemplate) {
      return true;
    }
    return false;
  }
  node.value.split("\n").forEach((value, index) => {
    const columnStart = index === 0 ? startCol : 0;
    const range = [start, start + value.length];
    const loc = {
      start: {
        line,
        column: columnStart
      },
      end: {
        line,
        column: columnStart + value.length
      }
    };
    const lineNode = {
      type: "Line",
      value,
      range,
      loc,
      skipIndentCheck: shouldSkipIndentCheck(range)
    };
    start += value.length + 1;
    line += 1;
    lineNodes.push(lineNode);
  });
  return lineNodes;
}
function getLocBetween(before, after) {
  return {
    start: before.loc.end,
    end: after.loc.start
  };
}
function isExpressionInTemplate(node) {
  if (node.type === import_parser.NODE_TYPES.AttributeValue) {
    return node.value.indexOf("${") === 0;
  }
  return false;
}
function isTag(node) {
  return node.type === import_parser.NODE_TYPES.Tag;
}
function isComment(node) {
  return node.type === import_parser.NODE_TYPES.Comment;
}
function isText(node) {
  return node.type === import_parser.NODE_TYPES.Text;
}
var lineBreakPattern = /\r\n|[\r\n\u2028\u2029]/u;
var lineEndingPattern = new RegExp(lineBreakPattern.source, "gu");
function codeToLines(source) {
  return source.split(lineEndingPattern);
}
function getTemplateTokens(tokens) {
  return [].concat(
    ...tokens.map((token) => token["templates"] || [])
  ).filter((token) => token.isTemplate);
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  codeToLines,
  findAttr,
  getLocBetween,
  getTemplateTokens,
  isAttributesEmpty,
  isComment,
  isExpressionInTemplate,
  isNodeTokensOnSameLine,
  isOverlapWithTemplates,
  isRangesOverlap,
  isTag,
  isText,
  splitToLineNodes
});
//# sourceMappingURL=node.js.map