tungsten 0.2.0 → 0.2.2

package/dist/postcssPlugins/parseSelectors.js

@@ -0,0 +1,161 @@
+import { throwError } from "../throwError.js";
+// | 'attribute-name-search' | 'attribute-name' | 'attribute-equals-search' | 'attribute-equals'
+// | 'attribute-value-search' | 'attribute-value' | 'attribute-end-search'
+export function parseSelectors(selectorGroup) {
+  let mode = 'search';
+  let selector = '';
+  const selectors = [];
+  let pseudoOpenBrackets = 0;
+  let pos = 0;
+  while (pos < selectorGroup.length) {
+    const char = selectorGroup[pos];
+    switch (mode) {
+      case 'search':
+        {
+          if (selector !== '') {
+            selectors.push(selector);
+            selector = '';
+          }
+          if (/[a-zA-Z]/.test(char)) {
+            mode = 'tag';
+            selector += char;
+            pos++;
+          } else if (/#/.test(char)) {
+            mode = 'id';
+            selector += char;
+            pos++;
+          } else if (/[.]/.test(char)) {
+            mode = 'class';
+            selector += char;
+            pos++;
+          } else if (/:/.test(char)) {
+            mode = 'pseudo';
+            selector += char;
+            pos++;
+          } else if (/\[/.test(char)) {
+            mode = 'attribute';
+            selector += char;
+            pos++;
+          } else {
+            // some chars here might be errors
+            pos++;
+          }
+          break;
+        }
+      case 'tag':
+        {
+          if (/[a-zA-Z0-9-]/.test(char)) {
+            selector += char;
+            pos++;
+          } else {
+            // some chars here should be errors
+            mode = 'search';
+          }
+          break;
+        }
+      case 'id':
+        {
+          if (selector.length === 1) {
+            // first char after #
+            if (/[a-zA-Z]/.test(char)) {
+              selector += char;
+              pos++;
+            } else {
+              // some chars here should be errors
+              mode = 'search';
+            }
+          } else {
+            if (/[a-zA-Z0-9-_:]/.test(char)) {
+              selector += char;
+              pos++;
+            } else {
+              mode = 'search';
+            }
+          }
+          break;
+        }
+      case 'class':
+        {
+          if (selector.length === 1) {
+            // first char after #
+            if (/[a-zA-Z-_]/.test(char)) {
+              selector += char;
+              pos++;
+            } else {
+              // some chars here should be errors
+              mode = 'search';
+            }
+          } else {
+            if (/[a-zA-Z0-9-_]/.test(char)) {
+              selector += char;
+              pos++;
+            } else {
+              mode = 'search';
+            }
+          }
+          break;
+        }
+      case 'pseudo':
+        {
+          if (pseudoOpenBrackets === 0) {
+            if (/[a-zA-Z0-9-_]/.test(char)) {
+              // not based on any spec, could not find one
+              selector += char;
+              pos++;
+            } else if (selector.length >= 2 && char === '(') {
+              selector += char;
+              pseudoOpenBrackets++;
+              pos++;
+            } else {
+              mode = 'search';
+            }
+          } else {
+            switch (char) {
+              case '(':
+                {
+                  selector += char;
+                  pseudoOpenBrackets++;
+                  pos++;
+                  break;
+                }
+              case ')':
+                {
+                  selector += char;
+                  pseudoOpenBrackets--;
+                  if (pseudoOpenBrackets === 0) {
+                    mode = 'search';
+                  }
+                  pos++;
+                  break;
+                }
+              default:
+                {
+                  selector += char;
+                  pos++;
+                }
+            }
+          }
+          break;
+        }
+      case 'attribute':
+        {
+          if (char === ']') {
+            selector += char;
+            mode = 'search';
+            pos++;
+          } else {
+            selector += char;
+            pos++;
+          }
+          break;
+        }
+      default:
+        {
+          throwError('parseSelectors', 'invalid mode');
+        }
+    }
+  }
+  if (selector.length > 0) selectors.push(selector);
+  return selectors;
+  //return selectorObjects
+}

package/dist/postcssPlugins/parseSelectors.sxyt.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parseSelectors.sxyt.d.ts.map

package/dist/postcssPlugins/parseSelectors.sxyt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSelectors.sxyt.d.ts","sourceRoot":"","sources":["../../src/postcssPlugins/parseSelectors.sxyt.ts"],"names":[],"mappings":""}

package/dist/postcssPlugins/parseSelectors.sxyt.js

@@ -0,0 +1,62 @@
+import { describe } from 'sxy-test-runner';
+import { parseSelectors } from "./parseSelectors.js";
+describe('parseSelectors()', ({
+  it
+}) => {
+  const input = 'html';
+  it(`parses out a tag selector from '${input}'`, () => {
+    const selectors = parseSelectors(input);
+    selectors.should.deep.equal(['html']);
+  });
+  const input2 = 'html body';
+  it(`parses out two tag selectors from '${input2}'`, () => {
+    const selectors = parseSelectors(input2);
+    selectors.should.deep.equal(['html', 'body']);
+  });
+  const input3 = '.foo';
+  it(`parses out a class selector from '${input3}'`, () => {
+    const selectors = parseSelectors(input3);
+    selectors.should.deep.equal(['.foo']);
+  });
+  const input4 = '  .foo ';
+  it(`parses out a class selector with whitespace from '${input4}'`, () => {
+    const selectors = parseSelectors(input4);
+    selectors.should.deep.equal(['.foo']);
+  });
+  const input5 = '.foo .bar';
+  it(`parses out a two class selectors from '${input5}'`, () => {
+    const selectors = parseSelectors(input5);
+    selectors.should.deep.equal(['.foo', '.bar']);
+  });
+  const input6 = 'html.bar';
+  it(`parses out connected tag and class '${input6}'`, () => {
+    const selectors = parseSelectors(input6);
+    selectors.should.deep.equal(['html', '.bar']);
+  });
+  const input7 = '.foo.bar';
+  it(`parses out connected classes '${input7}'`, () => {
+    const selectors = parseSelectors(input7);
+    selectors.should.deep.equal(['.foo', '.bar']);
+  });
+  const input8 = 'html#foo.bar';
+  it(`parses out connected tag, id and class '${input8}'`, () => {
+    const selectors = parseSelectors(input8);
+    selectors.should.deep.equal(['html', '#foo', '.bar']);
+  });
+  const input9 = 'html[lang="en"]';
+  it(`parses out tag with attribute selector from '${input9}'`, () => {
+    const selectors = parseSelectors(input9);
+    selectors.should.deep.equal(['html', '[lang="en"]']);
+  });
+  const input10 = ':i(div)';
+  it(`parses out :i pseudo '${input10}'`, () => {
+    const selectors = parseSelectors(input10);
+    selectors.should.deep.equal([':i(div)']);
+  });
+  const input11 = 'html :i(div)';
+  it(`parses out tag then :i pseudo '${input11}'`, () => {
+    const selectors = parseSelectors(input11);
+    //console.log('selectors', selectors)
+    selectors.should.deep.equal(['html', ':i(div)']);
+  });
+});

package/dist/postcssPlugins/parseSelectorsRich.d.ts

@@ -0,0 +1,8 @@
+export type SelectorKind = 'none' | 'whitespace' | 'grammar' | 'tag' | 'id' | 'class' | 'pseudo-class' | 'pseudo-element' | 'attribute';
+export type Selector = {
+    type: SelectorKind;
+    content: string;
+    valid: boolean;
+};
+export declare function parseSelectorsRich(selectorGroup: string): Selector[];
+//# sourceMappingURL=parseSelectorsRich.d.ts.map

package/dist/postcssPlugins/parseSelectorsRich.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSelectorsRich.d.ts","sourceRoot":"","sources":["../../src/postcssPlugins/parseSelectorsRich.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,YAAY,GAAG,SAAS,GAAG,KAAK,GAAG,IAAI,GAAG,OAAO,GAAG,cAAc,GAAG,gBAAgB,GAAG,WAAW,CAAA;AACvI,MAAM,MAAM,QAAQ,GAAG;IACnB,IAAI,EAAE,YAAY,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,OAAO,CAAA;CACjB,CAAA;AAMD,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,cAqPvD"}

package/dist/postcssPlugins/parseSelectorsRich.js

@@ -0,0 +1,276 @@
+import { throwError } from "../throwError.js";
+// | 'attribute-name-search' | 'attribute-name' | 'attribute-equals-search' | 'attribute-equals'
+// | 'attribute-value-search' | 'attribute-value' | 'attribute-end-search'
+export function parseSelectorsRich(selectorGroup) {
+  let mode = 'search';
+  let selectorObject = {
+    type: 'none',
+    content: '',
+    valid: false
+  };
+  const selectorObjects = [];
+  let pseudoOpenBrackets = 0;
+  let pos = 0;
+  while (pos < selectorGroup.length) {
+    const char = selectorGroup[pos];
+    switch (mode) {
+      case 'search':
+        {
+          if (selectorObject.type !== 'none' && selectorObject.content !== '') {
+            selectorObjects.push(selectorObject);
+            selectorObject = {
+              type: 'none',
+              content: '',
+              valid: false
+            };
+          }
+          if (/\s/.test(char)) {
+            // any whitespace
+            mode = 'whitespace';
+            selectorObject = {
+              type: 'whitespace',
+              content: ' ',
+              valid: true
+            };
+            pos++;
+          } else if (/[a-zA-Z]/.test(char)) {
+            mode = 'tag';
+            selectorObject = {
+              type: 'tag',
+              content: char,
+              valid: true
+            };
+            pos++;
+          } else if (/#/.test(char)) {
+            mode = 'id';
+            selectorObject = {
+              type: 'id',
+              content: char,
+              valid: false
+            };
+            pos++;
+          } else if (/[.]/.test(char)) {
+            mode = 'class';
+            selectorObject = {
+              type: 'class',
+              content: char,
+              valid: false
+            };
+            pos++;
+          } else if (/:/.test(char)) {
+            mode = 'pseudo';
+            selectorObject = {
+              type: 'none',
+              // will be pseudo-class or pseudo-element, we will set this later
+              content: char,
+              valid: false
+            };
+            pos++;
+          } else if (/\[/.test(char)) {
+            mode = 'attribute';
+            selectorObject = {
+              type: 'attribute',
+              content: char,
+              valid: false
+            };
+            pos++;
+          } else if (['+', '>'].includes(char)) {
+            // we don't include "," here, because the previous parser                                 
+            // separates comma separated selectors already
+            // save this grammar as a selectorObject, but leave it in search mode
+            // search mode will save this SO on the next iteration, and continue searching
+            // will need to change this if we find longer grammars
+            selectorObject = {
+              type: 'grammar',
+              content: char,
+              valid: true
+            };
+            pos++;
+          } else {
+            // some chars here might be errors
+            throwError('parseSelectorsRich', `Unexpected character when parsing stylesheet: ${char}`);
+            //pos++
+          }
+          break;
+        }
+      case 'whitespace':
+        {
+          if (/\s/.test(char)) {
+            pos++;
+          } else {
+            mode = 'search';
+          }
+          break;
+        }
+      case 'tag':
+        {
+          if (/[a-zA-Z0-9-]/.test(char)) {
+            selectorObject.content += char;
+            pos++;
+          } else {
+            // some chars here should be errors
+            mode = 'search';
+          }
+          break;
+        }
+      case 'id':
+        {
+          if (selectorObject.content.length === 1) {
+            // first char after #
+            if (/[a-zA-Z]/.test(char)) {
+              selectorObject.content += char;
+              selectorObject.valid = true;
+              pos++;
+            } else {
+              // some chars here should be errors
+              mode = 'search';
+            }
+          } else {
+            if (/[a-zA-Z0-9-_:]/.test(char)) {
+              selectorObject.content += char;
+              pos++;
+            } else {
+              mode = 'search';
+            }
+          }
+          break;
+        }
+      case 'class':
+        {
+          if (selectorObject.content.length === 1) {
+            // first char after #
+            if (/[a-zA-Z-_]/.test(char)) {
+              selectorObject.content += char;
+              selectorObject.valid = true;
+              pos++;
+            } else {
+              // some chars here should be errors
+              mode = 'search';
+            }
+          } else {
+            if (/[a-zA-Z0-9-_]/.test(char)) {
+              selectorObject.content += char;
+              pos++;
+            } else {
+              mode = 'search';
+            }
+          }
+          break;
+        }
+      // TODO -- handle pseudo with brackets
+      case 'pseudo':
+        {
+          if (/[a-zA-Z]/.test(char)) {
+            //console.log('its a pseudo class')
+            selectorObject.type = 'pseudo-class';
+            selectorObject.content += char;
+            //console.log(selectorObject.kind, selectorObject.content)
+            selectorObject.valid = true;
+            mode = 'pseudo-class';
+            pos++;
+          } else if (char === ':') {
+            selectorObject.type === 'pseudo-element';
+            selectorObject.content += char;
+            mode = 'pseudo-element';
+            pos++;
+          } else {
+            mode = 'search';
+          }
+          break;
+        }
+      case 'pseudo-class':
+        {
+          if (pseudoOpenBrackets === 0) {
+            // before any bracket, will never be 0 after opening
+            // because it will cycle mode on closing bracket
+            if (/[a-zA-Z0-9-_]/.test(char)) {
+              // not based on any spec, could not find one
+              selectorObject.content += char;
+              pos++;
+            } else if (char === '(') {
+              selectorObject.content += char;
+              pseudoOpenBrackets++;
+              pos++;
+            } else {
+              mode = 'search';
+            }
+          } else {
+            // after opening bracket
+            switch (char) {
+              case '(':
+                {
+                  selectorObject.content += char;
+                  pseudoOpenBrackets++;
+                  pos++;
+                  break;
+                }
+              case ')':
+                {
+                  selectorObject.content += char;
+                  pseudoOpenBrackets--;
+                  if (pseudoOpenBrackets === 0) {
+                    selectorObject.valid = true;
+                    mode = 'search';
+                  }
+                  pos++;
+                  break;
+                }
+              default:
+                {
+                  selectorObject.content += char;
+                  pos++;
+                }
+            }
+          }
+          break;
+        }
+      case 'pseudo-element':
+        {
+          if (selectorObject.content.length === 2) {
+            // first char after ::
+            if (/[a-zA-Z0-9]/.test(char)) {
+              // not based on any spec, could not find one
+              selectorObject.content += char;
+              selectorObject.valid = true;
+              pos++;
+            } else {
+              // invalid, continue
+              mode = 'search';
+            }
+          } else {
+            if (/[a-zA-Z0-9-_]/.test(char)) {
+              // not based on any spec, could not find one
+              selectorObject.content += char;
+              pos++;
+            } else {
+              // invalid, continue
+              mode = 'search';
+            }
+          }
+          break;
+        }
+      // TODO
+      case 'attribute':
+        {
+          if (char === ']') {
+            selectorObject.content += char;
+            selectorObject.valid = true;
+            mode = 'search';
+            pos++;
+          } else {
+            selectorObject.content += char;
+            pos++;
+          }
+          break;
+        }
+      default:
+        {
+          throwError('parseSelectors', 'invalid mode');
+        }
+    }
+  }
+  //console.log('end sel', JSON.stringify(selectorObject))
+  if (selectorObject.type !== 'none') selectorObjects.push(selectorObject);
+  //console.log(`parsed selectors [${selectorGroup}]:`, selectorObjects)
+  return selectorObjects;
+}

package/dist/postcssPlugins/parseSelectorsRich.sxyt.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parseSelectorsRich.sxyt.d.ts.map

package/dist/postcssPlugins/parseSelectorsRich.sxyt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSelectorsRich.sxyt.d.ts","sourceRoot":"","sources":["../../src/postcssPlugins/parseSelectorsRich.sxyt.ts"],"names":[],"mappings":""}

package/dist/postcssPlugins/parseSelectorsRich.sxyt.js

@@ -0,0 +1,130 @@
+import { describe } from 'sxy-test-runner';
+import { parseSelectorsRich } from "./parseSelectorsRich.js";
+function tagSelector(tag) {
+  return {
+    type: 'tag',
+    content: tag,
+    valid: true
+  };
+}
+function idSelector(id) {
+  return {
+    type: 'id',
+    content: id,
+    valid: true
+  };
+}
+function classSelector(className) {
+  return {
+    type: 'class',
+    content: className,
+    valid: true
+  };
+}
+function pseudoSelector(pesudo) {
+  return {
+    type: 'pseudo-class',
+    content: pesudo,
+    valid: true
+  };
+}
+function attributeSelector(attribute) {
+  return {
+    type: 'attribute',
+    content: attribute,
+    valid: true
+  };
+}
+function whitespace() {
+  return {
+    type: 'whitespace',
+    content: ' ',
+    valid: true
+  };
+}
+describe('parseSelectorsRich()', ({
+  it
+}) => {
+  const input = 'html';
+  it(`parses out a tag selector from '${input}'`, () => {
+    const selectors = parseSelectorsRich(input);
+    selectors.should.deep.equal([tagSelector('html')]);
+  });
+  const input2 = 'html body';
+  it(`parses out two tag selectors from '${input2}'`, () => {
+    const selectors = parseSelectorsRich(input2);
+    console.log('selectors', selectors);
+    console.log('expected', [tagSelector('html'), tagSelector('body')]);
+    selectors.should.deep.equal([tagSelector('html'), whitespace(), tagSelector('body')]);
+  });
+  const input3 = '.foo';
+  it(`parses out a class selector from '${input3}'`, () => {
+    const selectors = parseSelectorsRich(input3);
+    selectors.should.deep.equal([classSelector('.foo')]);
+  });
+  const input4 = '  .foo ';
+  it(`parses out a class selector with whitespace from '${input4}'`, () => {
+    const selectors = parseSelectorsRich(input4);
+    selectors.should.deep.equal([whitespace(), classSelector('.foo'), whitespace()]);
+  });
+  const input5 = '.foo .bar';
+  it(`parses out a two class selectors from '${input5}'`, () => {
+    const selectors = parseSelectorsRich(input5);
+    selectors.should.deep.equal([classSelector('.foo'), whitespace(), classSelector('.bar')]);
+  });
+  const input6 = 'html.bar';
+  it(`parses out connected tag and class '${input6}'`, () => {
+    const selectors = parseSelectorsRich(input6);
+    selectors.should.deep.equal([tagSelector('html'), classSelector('.bar')]);
+  });
+  const input7 = '.foo.bar';
+  it(`parses out connected classes '${input7}'`, () => {
+    const selectors = parseSelectorsRich(input7);
+    selectors.should.deep.equal([classSelector('.foo'), classSelector('.bar')]);
+  });
+  const input8 = 'html#foo.bar';
+  it(`parses out connected tag, id and class '${input8}'`, () => {
+    const selectors = parseSelectorsRich(input8);
+    selectors.should.deep.equal([tagSelector('html'), idSelector('#foo'), classSelector('.bar')]);
+  });
+  const input9 = 'html[lang="en"]';
+  it(`parses out tag with attribute selector from '${input9}'`, () => {
+    const selectors = parseSelectorsRich(input9);
+    // console.log(JSON.stringify(selectors))
+    // console.log(JSON.stringify([
+    //     tagSelector('html'),
+    //     attributeSelector('[lang="en"]')
+    // ]))
+    selectors.should.deep.equal([tagSelector('html'), attributeSelector('[lang="en"]')]);
+  });
+  const input10 = 'html[lang="en"]';
+  it(`parses out tag with attribute selector from '${input10}'`, () => {
+    const selectors = parseSelectorsRich(input10);
+    // console.log(JSON.stringify(selectors))
+    // console.log(JSON.stringify([
+    //     tagSelector('html'),
+    //     attributeSelector('[lang="en"]')
+    // ]))
+    selectors.should.deep.equal([tagSelector('html'), attributeSelector('[lang="en"]')]);
+  });
+  const input11 = 'a:hover';
+  it(`parses out :hover pseudo on an anchor in '${input11}'`, () => {
+    const selectors = parseSelectorsRich(input11);
+    // console.log(JSON.stringify(selectors))
+    // console.log(JSON.stringify([
+    //     tagSelector('a'),
+    //     pseudoSelector(':hover')
+    // ]))
+    selectors.should.deep.equal([tagSelector('a'), pseudoSelector(':hover')]);
+  });
+  const input12 = ':i(div)';
+  it(`parses out :i pseudo '${input12}'`, () => {
+    const selectors = parseSelectorsRich(input12);
+    selectors.should.deep.equal([pseudoSelector(':i(div)')]);
+  });
+  const input13 = 'html :i(div)';
+  it(`parses out tag then :i pseudo '${input13}'`, () => {
+    const selectors = parseSelectorsRich(input13);
+    selectors.should.deep.equal([tagSelector('html'), whitespace(), pseudoSelector(':i(div)')]);
+  });
+});

package/dist/promise.d.ts

@@ -0,0 +1,2 @@
+export declare function promise<T>(func: (resolve: (reason?: any) => void, reject: (reason?: any) => void) => T): Promise<T>;
+//# sourceMappingURL=promise.d.ts.map

package/dist/promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["../src/promise.ts"],"names":[],"mappings":"AACA,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,IAAI,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,IAAI,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAKnH"}

package/dist/promise.js

@@ -0,0 +1,6 @@
+export function promise(func) {
+  return new Promise((resolve, reject) => {
+    // func can be async 
+    func(resolve, reject);
+  });
+}

package/dist/reRouting/addRequireResolveHooks.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=addRequireResolveHooks.d.ts.map

package/dist/reRouting/addRequireResolveHooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addRequireResolveHooks.d.ts","sourceRoot":"","sources":["../../src/reRouting/addRequireResolveHooks.ts"],"names":[],"mappings":""}