@salesforcedevs/dx-components 0.58.1-alpha.1 → 0.59.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforcedevs/dx-components",
-    "version": "0.58.1-alpha.1+cdb39321",
+    "version": "0.59.0-alpha.1",
     "description": "DX Lightning web components",
     "license": "MIT",
     "engines": {
@@ -24,6 +24,5 @@
         "@types/debounce": "^1.2.0",
         "@types/lodash.get": "^4.4.6",
         "@types/vimeo__player": "^2.16.2"
-    },
-    "gitHead": "cdb39321a024284380127490c9a07f81dbfd0f36"
+    }
 }

package/src/modules/dx/codeBlock/codeBlock.ts

@@ -1,6 +1,7 @@
 import { LightningElement, api, wire, track } from "lwc";
 import { CodeBlockTheme, CodeBlockLanguage } from "typings/custom";
 import cx from "classnames";
+import { detect } from "dxUtils/codeLanguageDetector";
 import Prism from "dxUtils/prismjs";
 import {
     getLocalStorageData,
@@ -212,6 +213,18 @@ export default class CodeBlock extends LightningElement {
             ) || this.allLanguages[0];
         this.selectedLanguageLabel = this.selectedLanguage.label;
         this.selectedLanguageId = this.selectedLanguage.id;
+
+        // Auto detect code language if it isn't specified
+        if (!this.language) {
+            const detectedLanguage = detect(this.codeBlock);
+            this.selectedLanguage = {
+                label: detectedLanguage,
+                id: detectedLanguage.toLowerCase()
+            };
+            this.selectedLanguageLabel = detectedLanguage;
+            this.selectedLanguageId = detectedLanguage.toLowerCase();
+        }
+
         this.formatCodeBlock();
         this._codeBlockRendered = true;
     }

package/src/modules/dxUtils/codeLanguageDetector/codeLanguageDetector.js

@@ -0,0 +1,439 @@
+const LANGUAGES = {
+    JavaScript: [
+        // undefined keyword
+        { pattern: /undefined/g, points: 2 },
+        // console.log('ayy lmao')
+        { pattern: /console\.log( )*\(/, points: 2 },
+        // Variable declaration
+        { pattern: /(var|const|let)( )+\w+( )*=?/, points: 2 },
+        // Array/Object declaration
+        { pattern: /(('|").+('|")( )*|\w+):( )*[{[]/, points: 2 },
+        // === operator
+        { pattern: /===/g, points: 1 },
+        // !== operator
+        { pattern: /!==/g, points: 1 },
+        // Function definition
+        {
+            pattern: /function\*?(( )+[$\w]+( )*\(.*\)|( )*\(.*\))/g,
+            points: 1
+        },
+        // null keyword
+        { pattern: /null/g, points: 1 },
+        // lambda expression
+        { pattern: /\(.*\)( )*=>( )*.+/, points: 1 },
+        // (else )if statement
+        { pattern: /(else )?if( )+\(.+\)/, points: 1 },
+        // while loop
+        { pattern: /while( )+\(.+\)/, points: 1 },
+        // C style variable declaration.
+        {
+            pattern: /(^|\s)(char|long|int|float|double)( )+\w+( )*=?/,
+            points: -1
+        },
+        // pointer
+        { pattern: /(\w+)( )*\*( )*\w+/, points: -1 },
+        // HTML <script> tag
+        {
+            pattern: /<(\/)?script( type=('|")text\/javascript('|"))?>/,
+            points: -50
+        },
+        // ES6 import / export
+        {
+            pattern:
+                /(import|export(\s+)default)\s+({\s+[\w\s,]+\s+}|\w+)\s+from\s/,
+            points: 2
+        },
+        // ES6 arrow function
+        { pattern: /\([^()]{0,}\)\s+=>(\s+{)?/, points: 3 }
+        // () => {}
+        // (a) => {}
+        // (a, b) => {}
+        // ({ a, b}) => {}
+        // ([ a, b ]) => {}
+    ],
+
+    C: [
+        // Primitive variable declaration.
+        { pattern: /(char|long|int|float|double)( )+\w+( )*=?/, points: 2 },
+        // malloc function call
+        { pattern: /malloc\(.+\)/, points: 2 },
+        // #include <whatever.h>
+        { pattern: /#include (<|")\w+\.h(>|")/, points: 2, nearTop: true },
+        // pointer
+        { pattern: /(\w+)( )*\*( )*\w+/, points: 2 },
+        // Variable declaration and/or initialisation.
+        { pattern: /(\w+)( )+\w+(;|( )*=)/, points: 1 },
+        // Array declaration.
+        { pattern: /(\w+)( )+\w+\[.+\]/, points: 1 },
+        // #define macro
+        { pattern: /#define( )+.+/, points: 1 },
+        // NULL constant
+        { pattern: /NULL/, points: 1 },
+        // void keyword
+        { pattern: /void/g, points: 1 },
+        // (else )if statement
+        { pattern: /(else )?if( )*\(.+\)/, points: 1 },
+        // while loop
+        { pattern: /while( )+\(.+\)/, points: 1 },
+        // printf function
+        { pattern: /(printf|puts)( )*\(.+\)/, points: 1 },
+        // new Keyword from C++
+        { pattern: /new \w+/, points: -1 },
+        // Single quote multicharacter string
+        { pattern: /'.{2,}'/, points: -1 },
+        // JS variable declaration
+        { pattern: /var( )+\w+( )*=?/, points: -1 }
+    ],
+
+    "C++": [
+        // Primitive variable declaration.
+        { pattern: /(char|long|int|float|double)( )+\w+( )*=?/, points: 2 },
+        // #include <whatever.h>
+        {
+            pattern: /#include( )*(<|")\w+(\.h)?(>|")/,
+            points: 2,
+            nearTop: true
+        },
+        // using namespace something
+        { pattern: /using( )+namespace( )+.+( )*;/, points: 2 },
+        // template declaration
+        { pattern: /template( )*<.*>/, points: 2 },
+        // std
+        { pattern: /std::\w+/g, points: 2 },
+        // cout/cin/endl
+        { pattern: /(cout|cin|endl)/g, points: 2 },
+        // Visibility specifiers
+        { pattern: /(public|protected|private):/, points: 2 },
+        // nullptr
+        { pattern: /nullptr/, points: 2 },
+        // new Keyword
+        { pattern: /new \w+(\(.*\))?/, points: 1 },
+        // #define macro
+        { pattern: /#define( )+.+/, points: 1 },
+        // template usage
+        { pattern: /\w+<\w+>/, points: 1 },
+        // class keyword
+        { pattern: /class( )+\w+/, points: 1 },
+        // void keyword
+        { pattern: /void/g, points: 1 },
+        // (else )if statement
+        { pattern: /(else )?if( )*\(.+\)/, points: 1 },
+        // while loop
+        { pattern: /while( )+\(.+\)/, points: 1 },
+        // Scope operator
+        { pattern: /\w*::\w+/, points: 1 },
+        // Single quote multicharacter string
+        { pattern: /'.{2,}'/, points: -1 },
+        // Java List/ArrayList
+        {
+            pattern: /(List<\w+>|ArrayList<\w*>( )*\(.*\))(( )+[\w]+|;)/,
+            points: -1
+        }
+    ],
+
+    Python: [
+        // Function definition
+        { pattern: /def( )+\w+\(.*\)( )*:/, points: 2 },
+        // while loop
+        { pattern: /while (.+):/, points: 2 },
+        // from library import something
+        { pattern: /from [\w.]+ import (\w+|\*)/, points: 2 },
+        // class keyword
+        { pattern: /class( )*\w+(\(( )*\w+( )*\))?( )*:/, points: 2 },
+        // if keyword
+        { pattern: /if( )+(.+)( )*:/, points: 2 },
+        // elif keyword
+        { pattern: /elif( )+(.+)( )*:/, points: 2 },
+        // else keyword
+        { pattern: /else:/, points: 2 },
+        // for loop
+        { pattern: /for (\w+|\(?\w+,( )*\w+\)?) in (.+):/, points: 2 },
+        // Python variable declaration.
+        { pattern: /\w+( )*=( )*\w+(?!;)(\n|$)/, points: 1 },
+        // import something
+        { pattern: /import ([[^.]\w])+/, points: 1, nearTop: true },
+        // print statement/function
+        { pattern: /print((( )*\(.+\))|( )+.+)/, points: 1 },
+        // &&/|| operators
+        { pattern: /(&{2}|\|{2})/, points: -1 }
+    ],
+
+    Java: [
+        // System.out.println() etc.
+        { pattern: /System\.(in|out)\.\w+/, points: 2 },
+        // Class variable declarations
+        {
+            pattern: /(private|protected|public)( )*\w+( )*\w+(( )*=( )*[\w])?/,
+            points: 2
+        },
+        // Method
+        {
+            pattern: /(private|protected|public)( )*\w+( )*[\w]+\(.+\)/,
+            points: 2
+        },
+        // String class
+        { pattern: /(^|\s)(String)( )+[\w]+( )*=?/, points: 2 },
+        // List/ArrayList
+        {
+            pattern: /(List<\w+>|ArrayList<\w*>( )*\(.*\))(( )+[\w]+|;)/,
+            points: 2
+        },
+        // class keyword
+        { pattern: /(public( )*)?class( )*\w+/, points: 2 },
+        // Array declaration.
+        { pattern: /(\w+)(\[( )*\])+( )+\w+/, points: 2 },
+        // final keyword
+        { pattern: /final( )*\w+/, points: 2 },
+        // getter & setter
+        { pattern: /\w+\.(get|set)\(.+\)/, points: 2 },
+        // new Keyword (Java)
+        { pattern: /new [A-Z]\w*( )*\(.+\)/, points: 2 },
+        // C style variable declaration.
+        {
+            pattern: /(^|\s)(char|long|int|float|double)( )+[\w]+( )*=?/,
+            points: 1
+        },
+        // extends/implements keywords
+        { pattern: /(extends|implements)/, points: 2, nearTop: true },
+        // null keyword
+        { pattern: /null/g, points: 1 },
+        // (else )if statement
+        { pattern: /(else )?if( )*\(.+\)/, points: 1 },
+        // while loop
+        { pattern: /while( )+\(.+\)/, points: 1 },
+        // void keyword
+        { pattern: /void/g, points: 1 },
+        // const
+        { pattern: /const( )*\w+/, points: -1 },
+        // pointer
+        { pattern: /(\w+)( )*\*( )*\w+/, points: -1 },
+        // Single quote multicharacter string
+        { pattern: /'.{2,}'/, points: -1 },
+        // C style include
+        {
+            pattern: /#include( )*(<|")\w+(\.h)?(>|")/,
+            points: -1,
+            nearTop: true
+        }
+    ],
+
+    HTML: [
+        {
+            pattern: /<!DOCTYPE (html|HTML PUBLIC .+)>/,
+            points: 2,
+            nearTop: true
+        },
+        // Tags
+        {
+            pattern: /<[a-z0-9]+(( )*[\w]+=('|").+('|")( )*)?>.*<\/[a-z0-9]+>/g,
+            points: 2
+        },
+        // Properties
+        { pattern: /[a-z-]+=("|').+("|')/g, points: 2 },
+        // PHP tag
+        { pattern: /<\?php/, points: -50 }
+    ],
+
+    CSS: [
+        // Properties
+        { pattern: /[a-z-]+:(?!:).+;/, points: 2 },
+        // <style> tag from HTML
+        { pattern: /<(\/)?style>/, points: -50 }
+    ],
+
+    Ruby: [
+        // require/include
+        {
+            pattern: /(require|include)( )+'\w+(\.rb)?'/,
+            points: 2,
+            nearTop: true
+        },
+        // Function definition
+        { pattern: /def( )+\w+( )*(\(.+\))?( )*\n/, points: 2 },
+        // Instance variables
+        { pattern: /@\w+/, points: 2 },
+        // Boolean property
+        { pattern: /\.\w+\?/, points: 2 },
+        // puts (Ruby print)
+        { pattern: /puts( )+("|').+("|')/, points: 2 },
+        // Inheriting class
+        { pattern: /class [A-Z]\w*( )*<( )*([A-Z]\w*(::)?)+/, points: 2 },
+        // attr_accessor
+        { pattern: /attr_accessor( )+(:\w+(,( )*)?)+/, points: 2 },
+        // new
+        { pattern: /\w+\.new( )+/, points: 2 },
+        // elsif keyword
+        { pattern: /elsif/, points: 2 },
+        // do
+        { pattern: /do( )*\|(\w+(,( )*\w+)?)+\|/, points: 2 },
+        // for loop
+        { pattern: /for (\w+|\(?\w+,( )*\w+\)?) in (.+)/, points: 1 },
+        // nil keyword
+        { pattern: /nil/, points: 1 },
+        // Scope operator
+        { pattern: /[A-Z]\w*::[A-Z]\w*/, points: 1 }
+    ],
+
+    Go: [
+        // package something
+        { pattern: /package( )+[a-z]+\n/, points: 2, nearTop: true },
+        // import
+        {
+            pattern: /(import( )*\(( )*\n)|(import( )+"[a-z0-9/.]+")/,
+            points: 2,
+            nearTop: true
+        },
+        // error check
+        { pattern: /if.+err( )*!=( )*nil.+{/, points: 2 },
+        // Go print
+        { pattern: /fmt\.Print(f|ln)?\(.*\)/, points: 2 },
+        // function
+        { pattern: /func(( )+\w+( )*)?\(.*\).*{/, points: 2 },
+        // variable initialisation
+        { pattern: /\w+( )*:=( )*.+[^;\n]/, points: 2 },
+        // if/else if
+        { pattern: /(}( )*else( )*)?if[^()]+{/, points: 2 },
+        // var/const declaration
+        { pattern: /(var|const)( )+\w+( )+[\w*]+(\n|( )*=|$)/, points: 2 },
+        // public access on package
+        { pattern: /[a-z]+\.[A-Z]\w*/, points: 1 },
+        // nil keyword
+        { pattern: /nil/, points: 1 },
+        // Single quote multicharacter string
+        { pattern: /'.{2,}'/, points: -1 }
+    ],
+
+    PHP: [
+        // PHP tag
+        { pattern: /<\?php/, points: 2 },
+        // PHP style variables.
+        { pattern: /\$\w+/, points: 2 },
+        // use Something\Something;
+        { pattern: /use( )+\w+(\\\w+)+( )*;/, points: 2, nearTop: true },
+        // arrow
+        { pattern: /\$\w+->\w+/, points: 2 },
+        // require/include
+        {
+            pattern:
+                /(require|include)(_once)?( )*\(?( )*('|").+\.php('|")( )*\)?( )*;/,
+            points: 2
+        },
+        // echo 'something';
+        { pattern: /echo( )+('|").+('|")( )*;/, points: 1 },
+        // NULL constant
+        { pattern: /NULL/, points: 1 },
+        // new keyword
+        { pattern: /new( )+((\\\w+)+|\w+)(\(.*\))?/, points: 1 },
+        // Function definition
+        { pattern: /function(( )+[$\w]+\(.*\)|( )*\(.*\))/g, points: 1 },
+        // (else)if statement
+        { pattern: /(else)?if( )+\(.+\)/, points: 1 },
+        // scope operator
+        { pattern: /\w+::\w+/, points: 1 },
+        // === operator
+        { pattern: /===/g, points: 1 },
+        // !== operator
+        { pattern: /!==/g, points: 1 },
+        // C/JS style variable declaration.
+        {
+            pattern: /(^|\s)(var|char|long|int|float|double)( )+\w+( )*=?/,
+            points: -1
+        }
+    ],
+
+    Unknown: []
+};
+
+function getPoints(language, lineOfCode, checkers) {
+    return checkers
+        .map((checker) => {
+            if (checker.pattern.test(lineOfCode)) {
+                return checker.points;
+            }
+            return 0;
+        })
+        .reduce((memo, num) => memo + num, 0);
+}
+
+function detect(snippet, options) {
+    const opts = Object.assign(
+        {
+            heuristic: true,
+            statistics: false
+        },
+        options || {}
+    );
+
+    let linesOfCode = snippet
+        .replace(/\r\n?/g, "\n")
+        .replace(/\n{2,}/g, "\n")
+        .split("\n");
+
+    function nearTop(index) {
+        if (linesOfCode.length <= 10) {
+            return true;
+        }
+        return index < linesOfCode.length / 10;
+    }
+
+    if (opts.heuristic && linesOfCode.length > 500) {
+        linesOfCode = linesOfCode.filter((lineOfCode, index) => {
+            if (nearTop(index)) {
+                return true;
+            }
+            return index % Math.ceil(linesOfCode.length / 500) === 0;
+        });
+    }
+
+    const pairs = Object.keys(LANGUAGES).map((key) => {
+        return { language: key, checkers: LANGUAGES[key] };
+    });
+
+    const results = pairs.map((pair) => {
+        const language = pair.language;
+        const checkers = pair.checkers;
+
+        if (language === "Unknown") {
+            return { language: "Unknown", points: 1 };
+        }
+
+        const pointsList = linesOfCode.map((lineOfCode, index) => {
+            if (!nearTop(index)) {
+                return getPoints(
+                    language,
+                    lineOfCode,
+                    checkers.filter((checker) => !checker.nearTop)
+                );
+            }
+            return getPoints(language, lineOfCode, checkers);
+        });
+
+        const points = pointsList.reduce((memo, num) => memo + num);
+
+        return { language, points };
+    });
+
+    const sortedResult = results.sort(
+        (prev, next) => prev.points - next.points
+    );
+    const bestResult = sortedResult[sortedResult.length - 1];
+
+    if (opts.statistics) {
+        const statistics = {};
+        results.forEach((result) => {
+            statistics[result.language] = result.points;
+        });
+        return { detected: bestResult.language, statistics };
+    }
+
+    return bestResult.language;
+}
+
+const languages = Object.keys(LANGUAGES);
+const LANG = {};
+
+languages.forEach((language) => {
+    LANG[language] = language;
+});
+
+export { detect, languages, LANG };

package/LICENSE

@@ -1,12 +0,0 @@
-Copyright (c) 2020, Salesforce.com, Inc.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-
-* Neither the name of Salesforce.com nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.