tungsten 0.1.6 → 0.1.24

package/dist/build/resolveSassScssImports.js

@@ -0,0 +1,45 @@
+import { dirname, join } from 'path';
+export function resolveScssImport(url, fullSourceFile, importBase) {
+  //console.log('resolving sass import:', url)
+  //console.log('url', url)
+  //console.log('fullSourceFile', fullSourceFile)
+  //console.log('importBase', importBase)
+  let resolved;
+  if (url.startsWith('./') || url.startsWith('../')) {
+    // rel
+    resolved = join(dirname(fullSourceFile), url);
+  } else {
+    resolved = join(importBase, url);
+  }
+  // rel import
+  // abs import
+  // scss import base
+  // fullFile
+  // sourceDir
+  // sassBaseDir
+  //const resolved = url
+  //console.log(`SCSS import '${url}' resolved to:`, resolved)
+  return resolved;
+}
+export function resolveSassImport(url, fullSourceFile, importBase) {
+  //console.log('resolving sass import:', url)
+  //console.log('url', url)
+  //console.log('fullSourceFile', fullSourceFile)
+  //console.log('importBase', importBase)
+  let resolved;
+  if (url.startsWith('./') || url.startsWith('../')) {
+    //console.log('found rel import')
+    // rel
+    //console.log('join', fullSourceFile, url)
+    resolved = join(dirname(fullSourceFile), url);
+  } else {
+    //console.log('found importBase import')
+    resolved = join(importBase, url);
+  }
+  // fullFile
+  // sourceDir
+  // sassBaseDir
+  //const resolved = url
+  //console.log(`SASS import '${url}' resolved to:`, resolved)
+  return resolved;
+}

package/dist/build/rollup.user.prod.config.d.ts

@@ -0,0 +1,6 @@
+type RollupConfig = {
+    [key: string]: any;
+};
+declare const rollupConfig: RollupConfig;
+export default rollupConfig;
+//# sourceMappingURL=rollup.user.prod.config.d.ts.map

package/dist/build/rollup.user.prod.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup.user.prod.config.d.ts","sourceRoot":"","sources":["../../src/build/rollup.user.prod.config.ts"],"names":[],"mappings":"AAWA,KAAK,YAAY,GAAG;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACrB,CAAA;AAED,QAAA,MAAM,YAAY,EAAE,YAanB,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/build/rollup.user.prod.config.js

@@ -0,0 +1,21 @@
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+import commonjs from "@rollup/plugin-commonjs";
+//import { babel } from "@rollup/plugin-babel"
+import { terser } from "rollup-plugin-terser";
+//import terser from "@rollup/plugin-terser" // to do
+//import gzip from "rollup-plugin-gzip"
+import jsonModule from "@rollup/plugin-json";
+const json = jsonModule.default;
+const rollupConfig = {
+  plugins: [json(), nodeResolve(), commonjs(),
+  // must be before babel
+  ////babel({ babelHelpers: 'bundled' }), // must be after commonjs
+  terser({
+    keep_classnames: true,
+    keep_fnames: true
+  })
+  ////gzip(),
+  ]
+  //strictDeprecations: true // help prep for upgrade to rollup 3 -- this complains about the inlineDynamicImports CLI arg
+};
+export default rollupConfig;

package/dist/build/sassImportParser.d.ts

@@ -0,0 +1,6 @@
+export type ImportTarget = {
+    target: string;
+    start: number;
+};
+export declare function sassImportParser(code: string): ImportTarget[];
+//# sourceMappingURL=sassImportParser.d.ts.map

package/dist/build/sassImportParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sassImportParser.d.ts","sourceRoot":"","sources":["../../src/build/sassImportParser.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,YAAY,GAAG;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAA;CAChB,CAAA;AAMD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,CA4R7D"}

package/dist/build/sassImportParser.js

@@ -0,0 +1,294 @@
+/* eslint-disable no-inner-declarations */
+function debug(...texts) {
+  //console.log(...texts)
+}
+export function sassImportParser(code) {
+  try {
+    let mode = 'search';
+    let commentMode = 'none';
+    const imports = [];
+    let indentationChar = null;
+    let indentation = {
+      space: 0,
+      tab: 0
+    };
+    let statement = 'none';
+    let firstLevelIndentation = null;
+    //let secondLevelIndentation: ValidIndentation | null = null
+    let atRule = '';
+    let openQuote = null;
+    let atUseImportTarget = '';
+    let atUseImportTargetStart = -1;
+    function finishAtRule(char) {
+      switch (atRule) {
+        case '':
+          throw new Error('Expected identifier after @');
+        case 'use':
+        case 'import':
+          if (char === `'` || char === `"`) {
+            openQuote = char;
+            mode = 'at-use-import-target';
+          } else {
+            mode = 'at-use-import';
+          }
+          break;
+      }
+      atRule = '';
+    }
+    function errOnMixedSpacesAndTabs(i) {
+      if (i.space > 0 && i.tab > 0) throw new Error('Error, found mixed spaces and tabs');
+      return true;
+    }
+    function IndentationIsValidIndentationOrThrow(i) {
+      errOnMixedSpacesAndTabs(i);
+      return true;
+    }
+    function hasIndentation(i) {
+      return i.tab > 0 || i.space > 0;
+    }
+    function getIndentationChar(i) {
+      if (i.space > 0) {
+        return 'space';
+      } else if (i.tab > 0) {
+        return 'tab';
+      } else {
+        return null;
+      }
+    }
+    function handleFirstLevelIndentation(i) {
+      if (IndentationIsValidIndentationOrThrow(i)) {
+        if (hasIndentation(i)) {
+          if (indentationChar === null) {
+            indentationChar = getIndentationChar(i);
+          } else {
+            if (getIndentationChar(i) !== indentationChar) {
+              throw new Error('Found mixed spaces and tabs');
+            }
+          }
+        }
+        firstLevelIndentation = i;
+      }
+    }
+    function compareIndentation(i, j) {
+      if (IndentationIsValidIndentationOrThrow(i) && IndentationIsValidIndentationOrThrow(j)) {
+        if (indentationChar === null) {
+          const iic = getIndentationChar(i);
+          const jic = getIndentationChar(j);
+          if (iic !== null) {
+            indentationChar = iic;
+            if (jic !== null && jic !== iic) throw new Error('Found mixed spaces and tabs');
+          } else {
+            if (jic !== null) indentationChar = jic;else {
+              return 0;
+            }
+          }
+        }
+        if (i[indentationChar] > j[indentationChar]) return 1;else if (i[indentationChar] < j[indentationChar]) return -1;else return 0;
+      }
+      throw new Error('never');
+    }
+    const lines = code.split('\n');
+    let lineIndex = -1;
+    let totalCharIndex = -2;
+    for (const line of lines) {
+      lineIndex++;
+      totalCharIndex++;
+      debug('line', lineIndex, line);
+      let charIndex = -1;
+      for (const char of line) {
+        charIndex++;
+        totalCharIndex++;
+        debug(mode, charIndex, totalCharIndex, char);
+        switch (commentMode) {
+          case 'none':
+            {
+              if (char === '/') {
+                if (line[charIndex + 1] === '/') {
+                  commentMode = 'line-comment';
+                  continue;
+                } else if (line[charIndex + 1] === '*') {
+                  commentMode = 'block-comment';
+                  continue;
+                }
+                //commentMode = 'slash'
+              }
+              break;
+            }
+          // case 'slash': {
+          //     if (char === '/') {
+          //         commentMode = 'line-comment'
+          //     } else if (char === '*') {
+          //         commentMode = 'block-comment'
+          //     }
+          //     break
+          // }
+          case 'line-comment':
+            {
+              // skip?
+              continue;
+            }
+          case 'block-comment':
+            {
+              // skip?
+              if (char === '*' && line[charIndex + 1] === '/') {
+                commentMode = 'block-comment-ending';
+              }
+              continue;
+            }
+          case 'block-comment-ending':
+            {
+              commentMode = 'none';
+              continue;
+            }
+          default:
+            {
+              throw new Error(`unknown commentMode ${commentMode}`);
+            }
+        }
+        switch (mode) {
+          // eslint-disable-line no-type-assertion/no-type-assertion -- TS incorrectly reduces type of mode
+          case 'search':
+            {
+              if (char === ' ') {
+                indentation.space++;
+              } else if (char === '\t') {
+                indentation.tab++;
+              } else if (char === '@') {
+                handleFirstLevelIndentation(indentation);
+                statement = 'at-rule';
+                mode = 'at-rule';
+              } else if (/\S/.test(char)) {
+                if (statement === 'selector') {
+                  if (IndentationIsValidIndentationOrThrow(indentation)) {
+                    if (firstLevelIndentation === null) throw new Error('internal error: firstLevelIndentation was null when comparing indentation');
+                    const result = compareIndentation(indentation, firstLevelIndentation);
+                    if (result === 1) {
+                      mode = 'style-rules';
+                      //secondLevelIndentation = indentation
+                      break;
+                    }
+                  }
+                }
+                handleFirstLevelIndentation(indentation);
+                statement = 'selector';
+                mode = 'selector';
+              }
+              break;
+            }
+          case 'at-rule':
+            {
+              if (/[a-zA-Z0-9-_]/.test(char)) {
+                atRule += char;
+              } else if (char === ' ' || char === '\t' || char === `'` || char === `"`) {
+                finishAtRule(char);
+              }
+              break;
+            }
+          case 'at-use-import':
+            {
+              if (char === ' ' || char === '\t') {
+                // ignore whitespace
+              } else if (char === `'`) {
+                openQuote = char;
+                mode = 'at-use-import-target';
+              } else if (char === `"`) {
+                openQuote = char;
+                mode = 'at-use-import-target';
+              }
+              break;
+            }
+          case 'at-use-import-target':
+            {
+              if (char === openQuote) {
+                debug(`Found import target '${atUseImportTarget}' at position ${atUseImportTargetStart}`);
+                imports.push({
+                  target: atUseImportTarget,
+                  start: atUseImportTargetStart
+                });
+                openQuote = null;
+                atUseImportTarget = '';
+                atUseImportTargetStart = -1;
+                mode = 'post-at-rule';
+              } else {
+                if (atUseImportTarget === '') {
+                  atUseImportTargetStart = totalCharIndex;
+                }
+                atUseImportTarget += char;
+              }
+              break;
+            }
+          case 'post-at-rule':
+            {
+              break;
+            }
+          case 'selector':
+            {
+              // don't care, line end will end this mode
+              break;
+            }
+          case 'style-rules':
+            {
+              // don't care what is in here until we break out
+              break;
+            }
+          default:
+            {
+              throw new Error(`unknown mode ${mode}`);
+            }
+        }
+      }
+      switch (commentMode) {
+        case 'line-comment':
+          {
+            commentMode = 'none';
+            break;
+          }
+      }
+      // end of line
+      switch (mode) {
+        // eslint-disable-line no-type-assertion/no-type-assertion -- TS incorrectly reduces type of mode
+        case 'at-rule':
+          {
+            finishAtRule();
+            mode = 'search';
+            break;
+          }
+        case 'at-use-import':
+          {
+            atRule = '';
+            mode = 'search';
+            throw new Error('Incomplete @import statement');
+          }
+        case 'at-use-import-target':
+          {
+            openQuote = null;
+            atUseImportTarget = '';
+            atUseImportTargetStart = -1;
+            mode = 'search';
+            break;
+          }
+        case 'post-at-rule':
+        case 'post-at-use-import':
+          {
+            mode = 'search';
+            break;
+          }
+        case 'selector':
+          {
+            if (IndentationIsValidIndentationOrThrow(indentation)) {
+              firstLevelIndentation = indentation;
+            }
+            mode = 'search';
+            break;
+          }
+      }
+      indentation = {
+        space: 0,
+        tab: 0
+      };
+    }
+    return imports;
+  } catch (e) {
+    return e;
+  }
+}

package/dist/build/sassImportParser.sxyt.d.ts

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

package/dist/build/sassImportParser.sxyt.d.ts.map

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

package/dist/build/sassImportParser.sxyt.js

@@ -0,0 +1,110 @@
+import { describe } from 'sxy-test-runner';
+import { sassImportParser } from "./sassImportParser.js";
+describe('sassImportParser()', ({
+  it
+}) => {
+  const input = `@import 'foo'`;
+  it(`parses out an import '${input}'`, () => {
+    const imports = sassImportParser(input);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo']);
+  });
+  const input2 = `@import 'foo'
+@import 'bar'`;
+  it(`parses out 2 imports from '${input2}'`, () => {
+    const imports = sassImportParser(input2);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input3 = `    
+    @import 'foo'
+
+    @import 'bar'
+    
+`;
+  it(`parses out 2 imports with spaces from '${input3}'`, () => {
+    const imports = sassImportParser(input3);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input4 = `    
+    @import 'foo'
+    @import 'bar'
+    p::after
+        content: "@import 'baz'"
+`;
+  it(`ignores extra imports within style values '${input4}'`, () => {
+    const imports = sassImportParser(input4);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input5 = `    
+    @import 'foo'
+    @import 'bar'
+    // @import 'ignoreme'
+    /* @use 'ignoremetoo' */
+    /*
+    @use 'ignoremealso'
+    */
+    @use 'baz'
+`;
+  it(`ignores imports within comments in '${input5}'`, () => {
+    const imports = sassImportParser(input5);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar', 'baz']);
+  });
+  const input6 = `    
+    @import /* comment */ 'foo'
+    @import /* comment */'bar'
+`;
+  it(`tolerates comments within @import and @use statements in '${input6}'`, () => {
+    const imports = sassImportParser(input6);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input7 = `    
+    @import'foo'
+    @import/* comment */'bar'
+`;
+  it(`does not require a space between @import / @use and the target using '${input7}'`, () => {
+    const imports = sassImportParser(input7);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input8 = `@import 'foo'`;
+  it(`returns a correct index for the start position when extracting from '${input8}'`, () => {
+    const imports = sassImportParser(input8);
+    Array.from(imports).should.deep.equal([{
+      target: 'foo',
+      start: 9
+    }]);
+  });
+  const input9 = `
+
+    @import 'bar'`;
+  it(`returns a correct index for the start position when extracting from '${input9}'`, () => {
+    const imports = sassImportParser(input9);
+    Array.from(imports).should.deep.equal([{
+      target: 'bar',
+      start: 15
+    }]);
+  });
+  const input10 = `@use 'foo' as bar`;
+  it(`handles aliasing in @use statements in '${input10}'`, () => {
+    const imports = sassImportParser(input10);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo']);
+  });
+  const input11 = `@use './foo' as bar`;
+  it(`extract relative targets from '${input11}'`, () => {
+    const imports = sassImportParser(input11);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['./foo']);
+  });
+  const input12 = `@use "foo" as bar`;
+  it(`handles double quotes in '${input12}'`, () => {
+    const imports = sassImportParser(input12);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo']);
+  });
+});

package/dist/build/scssImportParserChatgpt.d.ts

@@ -0,0 +1,6 @@
+export type ImportTarget = {
+    target: string;
+    start: number;
+};
+export declare function scssImportParserChatgpt(content: string): ImportTarget[];
+//# sourceMappingURL=scssImportParserChatgpt.d.ts.map

package/dist/build/scssImportParserChatgpt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scssImportParserChatgpt.d.ts","sourceRoot":"","sources":["../../src/build/scssImportParserChatgpt.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,YAAY,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE5D,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,CA6DvE"}

package/dist/build/scssImportParserChatgpt.js

@@ -0,0 +1,61 @@
+// Code by ChatGPT-3.5
+export function scssImportParserChatgpt(content) {
+  const importStatements = [];
+  let currentToken = '';
+  let currentStatementType = '';
+  let isInString = false;
+  let isEscaped = false;
+  let importStart = -1;
+  let isInsideBlockComment = false;
+  for (let i = 0; i < content.length; i++) {
+    const char = content[i];
+    if (char === '"' || char === '\'') {
+      if (!isInString) {
+        isInString = true;
+        importStart = i + 1; // Set importStart to the character after the opening quote
+      } else if (!isEscaped) {
+        isInString = false;
+      }
+    }
+    if (char === '\\' && isInString) {
+      isEscaped = true;
+    } else {
+      isEscaped = false;
+    }
+    if (char === '/' && content[i + 1] === '*' && !isInString) {
+      // Skip block comments
+      isInsideBlockComment = true;
+      i++; // Skip the opening comment character
+    } else if (char === '*' && content[i + 1] === '/' && isInsideBlockComment) {
+      isInsideBlockComment = false;
+      i++; // Skip the closing comment character
+    } else if (!isInsideBlockComment) {
+      if (char === ';' && !isInString) {
+        if (currentToken.trim() !== '') {
+          const targets = currentToken.trim().replace(/['"]/g, '').split(/\s+/);
+          if (currentStatementType === '@import' || currentStatementType === '@use') {
+            importStatements.push({
+              target: targets[0],
+              start: importStart
+            });
+          }
+        }
+        currentToken = '';
+        currentStatementType = '';
+      } else if (char === '@' && !isInString) {
+        currentStatementType = '';
+        currentToken = '';
+        if (content.slice(i, i + 7) === '@import') {
+          currentStatementType = '@import';
+          i += 6;
+        } else if (content.slice(i, i + 4) === '@use') {
+          currentStatementType = '@use';
+          i += 3;
+        }
+      } else {
+        currentToken += char;
+      }
+    }
+  }
+  return importStatements;
+}

package/dist/build/scssImportParserChatgpt.sxyt.d.ts

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

package/dist/build/scssImportParserChatgpt.sxyt.d.ts.map

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