@asamuzakjp/dom-selector 2.0.3-a.1 → 2.0.3-a.2

package/src/js/parser.js

@@ -7,9 +7,10 @@ import { findAll, parse, toPlainObject, walk } from 'css-tree';
 
 /* constants */
 import {
-  DUO, HEX, MAX_BIT_16, BIT_HYPHEN, REG_LOGICAL_PSEUDO, REG_SHADOW_PSEUDO,
-  SELECTOR, SELECTOR_PSEUDO_CLASS, SELECTOR_PSEUDO_ELEMENT, SYNTAX_ERR,
-  TYPE_FROM, TYPE_TO, U_FFFD
+  BIT_01, BIT_02, BIT_04, BIT_08, BIT_16, BIT_32, BIT_FFFF, BIT_HYPHEN,
+  DUO, HEX, REG_LOGICAL_PSEUDO, REG_SHADOW_PSEUDO, SELECTOR, SELECTOR_ATTR,
+  SELECTOR_CLASS, SELECTOR_ID, SELECTOR_PSEUDO_CLASS, SELECTOR_PSEUDO_ELEMENT,
+  SELECTOR_TYPE, SYNTAX_ERR, TYPE_FROM, TYPE_TO, U_FFFD
 } from './constant.js';
 
 /**
@@ -87,7 +88,7 @@ export const preprocess = (...args) => {
           throw new DOMException(`Invalid selector ${selector}`, SYNTAX_ERR);
         }
       // escape char above 0xFFFF
-      } else if (codePoint > MAX_BIT_16) {
+      } else if (codePoint > BIT_FFFF) {
         const str = `\\${codePoint.toString(HEX)} `;
         if (postHash.length === DUO) {
           postHash = str;
@@ -218,5 +219,65 @@ export const walkAST = (ast = {}) => {
   return [...branches];
 };
 
+/**
+ * sort AST
+ * @param {Array.<object>} asts - collection of AST
+ * @returns {Array.<object>} - collection of sorted AST
+ */
+export const sortAST = asts => {
+  const arr = [...asts];
+  if (arr.length > 1) {
+    const order = new Map([
+      [SELECTOR_PSEUDO_ELEMENT, BIT_01],
+      [SELECTOR_ID, BIT_02],
+      [SELECTOR_CLASS, BIT_04],
+      [SELECTOR_TYPE, BIT_08],
+      [SELECTOR_ATTR, BIT_16],
+      [SELECTOR_PSEUDO_CLASS, BIT_32]
+    ]);
+    arr.sort((a, b) => {
+      const { type: typeA } = a;
+      const { type: typeB } = b;
+      const bitA = order.get(typeA);
+      const bitB = order.get(typeB);
+      let res;
+      if (bitA === bitB) {
+        res = 0;
+      } else if (bitA > bitB) {
+        res = 1;
+      } else {
+        res = -1;
+      }
+      return res;
+    });
+  }
+  return arr;
+};
+
+/**
+ * parse AST name - e.g. ns|E -> { prefix: ns, localName: E }
+ * @private
+ * @param {string} selector - type selector
+ * @returns {object} - node properties
+ */
+export const parseAstName = selector => {
+  let prefix;
+  let localName;
+  if (selector && typeof selector === 'string') {
+    if (selector.indexOf('|') > -1) {
+      [prefix, localName] = selector.split('|');
+    } else {
+      prefix = '*';
+      localName = selector;
+    }
+  } else {
+    throw new DOMException(`Invalid selector ${selector}`, SYNTAX_ERR);
+  }
+  return {
+    prefix,
+    localName
+  };
+};
+
 /* export */
 export { generate as generateCSS } from 'css-tree';

package/types/index.d.ts

@@ -1,5 +1,5 @@
-export { Matcher };
-export let matcher: Matcher;
+export { Finder };
+export let finder: Finder;
 export function matches(selector: string, node: object, opt?: {
     warn?: boolean;
 }): boolean;
@@ -12,4 +12,4 @@ export function querySelector(selector: string, node: object, opt?: {
 export function querySelectorAll(selector: string, node: object, opt?: {
     warn?: boolean;
 }): Array<object | undefined>;
-import { Matcher } from './js/matcher.js';
+import { Finder } from './js/finder.js';

package/types/js/constant.d.ts

@@ -22,10 +22,10 @@ export const BIT_04: 4;
 export const BIT_08: 8;
 export const BIT_16: 16;
 export const BIT_32: 32;
+export const BIT_FFFF: 65535;
 export const BIT_HYPHEN: 45;
 export const DUO: 2;
 export const HEX: 16;
-export const MAX_BIT_16: 65535;
 export const TYPE_FROM: 8;
 export const TYPE_TO: -1;
 export const ELEMENT_NODE: 1;

package/types/js/dom-util.d.ts

@@ -1,3 +1,4 @@
+export function prepareDOMObjects(node: object): Array<object>;
 export function isInShadowTree(node?: object): boolean;
 export function getSlottedTextContent(node?: object): string | null;
 export function getDirectionality(node?: object): string | null;
@@ -5,4 +6,4 @@ export function isContentEditable(node?: object): boolean;
 export function isNamespaceDeclared(ns?: string, node?: object): boolean;
 export function isInclusive(nodeA?: object, nodeB?: object): boolean;
 export function isPreceding(nodeA?: object, nodeB?: object): boolean;
-export function selectorToNodeProps(selector: string, node?: object): object;
+export function sortNodes(nodes?: Array<object> | Set<object>): Array<object | undefined>;

package/types/js/finder.d.ts

@@ -0,0 +1,30 @@
+export class Finder {
+    private _onError;
+    private _setup;
+    private _correspond;
+    private _traverse;
+    private _collectNthChild;
+    private _collectNthOfType;
+    private _matchAnPlusB;
+    private _matchDirectionPseudoClass;
+    private _matchLanguagePseudoClass;
+    private _matchHasPseudoFunc;
+    private _matchLogicalPseudoFunc;
+    private _matchPseudoClassSelector;
+    private _matchShadowHostPseudoClass;
+    private _matchSelector;
+    private _matchLeaves;
+    private _findDescendantNodes;
+    private _matchCombinator;
+    private _findNode;
+    private _findEntryNodes;
+    private _getEntryTwig;
+    private _collectNodes;
+    private _matchNodes;
+    private _find;
+    matches(node: object, selector: string, opt: object): boolean;
+    closest(node: object, selector: string, opt: object): object | null;
+    querySelector(node: object, selector: string, opt: object): object | null;
+    querySelectorAll(node: object, selector: string, opt: object): Array<object | undefined>;
+    #private;
+}

package/types/js/matcher.d.ts

@@ -1,57 +1,11 @@
-export class Matcher {
-    _onError(e: Error): void;
-    _setup(node: object): Array<object>;
-    _sortLeaves(leaves: Array<object>): Array<object>;
-    _correspond(selector: string): Array<Array<object | undefined>>;
-    _traverse(node?: object, walker?: object): object | null;
-    _collectNthChild(anb: {
-        a: number;
-        b: number;
-        reverse?: boolean;
-        selector?: object;
-    }, node: object): Set<object>;
-    _collectNthOfType(anb: {
-        a: number;
-        b: number;
-        reverse?: boolean;
-    }, node: object): Set<object>;
-    _matchAnPlusB(ast: object, node: object, nthName: string): Set<object>;
-    _matchPseudoElementSelector(astName: string, opt?: {
-        forgive?: boolean;
-    }): void;
-    _matchDirectionPseudoClass(ast: object, node: object): object | null;
-    _matchLanguagePseudoClass(ast: object, node: object): object | null;
-    _matchHasPseudoFunc(leaves: Array<object>, node: object): boolean;
-    _matchLogicalPseudoFunc(astData: object, node: object): object | null;
-    _matchPseudoClassSelector(ast: object, node: object, opt?: {
-        forgive?: boolean;
-    }): Set<object>;
-    _matchAttributeSelector(ast: object, node: object): object | null;
-    _matchClassSelector(ast: object, node: object): object | null;
-    _matchIDSelector(ast: object, node: object): object | null;
-    _matchTypeSelector(ast: object, node: object, opt?: {
-        forgive?: boolean;
-    }): object | null;
-    _matchShadowHostPseudoClass(ast: object, node: object): object | null;
-    _matchSelector(ast: object, node: object, opt?: object): Set<object>;
-    _matchLeaves(leaves: Array<object>, node: object, opt?: object): boolean;
-    _findDescendantNodes(leaves: Array<object>, baseNode: object): object;
-    _matchCombinator(twig: object, node: object, opt?: {
-        dir?: string;
-        forgive?: boolean;
-    }): Set<object>;
-    _findNode(leaves: Array<object>, opt?: {
-        node?: object;
-    }): object | null;
-    _findEntryNodes(twig: object, targetType: string): object;
-    _getEntryTwig(branch: Array<object>, targetType: string): object;
-    _collectNodes(targetType: string): Array<Array<object | undefined>>;
-    _sortNodes(nodes: Array<object> | Set<object>): Array<object | undefined>;
-    _matchNodes(targetType: string): Set<object>;
-    _find(targetType: string, node: object, selector: string, opt?: object): Set<object>;
-    matches(node: object, selector: string, opt: object): boolean;
-    closest(node: object, selector: string, opt: object): object | null;
-    querySelector(node: object, selector: string, opt: object): object | null;
-    querySelectorAll(node: object, selector: string, opt: object): Array<object | undefined>;
-    #private;
-}
+export function _matchAttributeSelector(ast: object, node: object): object | null;
+export function _matchClassSelector(ast: object, node: object): object | null;
+export function _matchIDSelector(ast: object, node: object): object | null;
+export function _matchTypeSelector(ast: object, node: object, opt?: {
+    forgive?: boolean;
+}): object | null;
+export function matchSelector(ast: object, node: object, opt: object): object | null;
+export function matchPseudoElementSelector(astName: string, opt?: {
+    forgive?: boolean;
+    warn?: boolean;
+}): void;

package/types/js/parser.d.ts

@@ -2,4 +2,6 @@ export function unescapeSelector(selector?: string): string | null;
 export function preprocess(...args: any[]): string;
 export function parseSelector(selector: string): object;
 export function walkAST(ast?: object): Array<object | undefined>;
+export function sortAST(asts: Array<object>): Array<object>;
+export function parseAstName(selector: string): object;
 export { generate as generateCSS } from "css-tree";