babel-plugin-wallace 0.0.2 → 0.0.6

package/lib/utils/misc.js

@@ -1,152 +0,0 @@
-/**
- * Funtionality for working with JavaScript
- */
-const isFunc = (def) => typeof def === 'function'
-
-const isUnd = (def) => def === undefined
-
-const splitTrim = (str, char) => str.split(char).map(item => item.trim())
-
-const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1)
-
-/*
- * Converts an array of objects to one object with arrays.
- *
- * in:  [{k: 'a', ...}, {k: 'b', ...}]
- * out: {a: [...], b: [...]}
- */
-const groupArray = (ar, key, f) => {
-	const obj = {}
-	ar.forEach(i => {
-		let k = i[key]
-		if (!obj.hasOwnProperty(k)) {
-      obj[k] = []
-    }
-    obj[k].push(f(i))
-	})
-	return obj
-}
-
-/**
- * Returns undefined if string is only whitespace, else the original string.
- */
-function clearIfEmpty(str) {
-	if (str.trim().length > 0) {
-		return str
-	}
-}
-	
-const arrayStartsWith = (origin, test) => {
-	if (test.length <= origin.length) {
-		return false
-	}
-	for (const [i, v] of origin.entries()) {
-		if (test[i] !== v) {
-			return false
-		}
-	}
-	return true
-}
-
-/**
- * Replaces arg variables if found.
- * 
- * replaceArgs("foo(n, c, o)", "c", "component")  >>  "foo(n, component, o)"
- * replaceArgs("foo(n, c, o)", "X", "X")  >>  "foo(n, c, o)"
- * 
- * Only works on last set of brackets, so:
- * 
- * replaceArgs("foo(n, c, o).bar(c, p)", "c", "X")  >>  "foo(n, c, o).bar(X, p)"
- * 
- * @param {string} str 
- * @param {string} oldArg 
- * @param {string} newArg 
- */
-const replaceArgs = (str, oldArg, newArg) => {
-	const openArgBracket = str.lastIndexOf("(");
-	const closeArgBracket = str.lastIndexOf(")");
-	if (openArgBracket >=0 && closeArgBracket >= openArgBracket) {
-		const argString = str.slice(openArgBracket + 1, closeArgBracket)
-		const argsArray = argString.split(',').map(s => s.trim())
-		const argPostition = argsArray.indexOf(oldArg)
-		if (argPostition >= 0) {
-			argsArray[argPostition] = newArg
-			return str.slice(0, openArgBracket + 1) + argsArray.join(',') + ')'
-		}
-	}
-	return str
-}
-
-/*
- * Given an array of nodeIndexPaths such as
- *
- *   [
- *     [0],
- *     [0, 1],
- *     [0, 2],
- *     [1],
- *   ]
- *
- * It returns an array the number of nested items, like so:
- *
- *  [2, 0, 0, 0]
- *
- *
- */
-const extractShieldCounts = (paths) => {
-	const processedPaths = []
-
-	paths.forEach(path => {
-		processedPaths.forEach(processed => {
-			if (arrayStartsWith(processed.path, path)) {
-				processed.count ++
-			}
-		})
-		processedPaths.push({path: path, count: 0})
-	})
-	return processedPaths.map(i => i.count)
-}
-
-
-const escapeSingleQuotes = (text) => text.replace(/'/g, "\\'")
-const escapeDoubleQuotes = (text) => text.replace(/"/g, '\\"')
-
-const trimChar = (string, charToRemove) => {
-    while(string.charAt(0)==charToRemove) {
-        string = string.substring(1);
-    }
-    while(string.charAt(string.length-1)==charToRemove) {
-        string = string.substring(0,string.length-1);
-    }
-    return string;
-}
-
-const trimChars = (str, chars) => {
-    var start = 0, 
-        end = str.length;
-
-    while(start < end && chars.indexOf(str[start]) >= 0)
-        ++start;
-
-    while(end > start && chars.indexOf(str[end - 1]) >= 0)
-        --end;
-
-    return (start > 0 || end < str.length) ? str.substring(start, end) : str;
-}
-
-
-module.exports = {
-	arrayStartsWith,
-	capitalize,
-	clearIfEmpty,
-	escapeSingleQuotes,
-	escapeDoubleQuotes,
-	extractShieldCounts,
-	groupArray,
-	isFunc,
-	isUnd,
-	replaceArgs,
-	splitTrim,
-	trimChar,
-	trimChars
-}

package/lib_old/handlers.js

@@ -1,52 +0,0 @@
-const {RequestsHelp, FrameworkError} = require('./definitions/constants')
-const {CodeGenerator} = require('./generate/code_generator')
-const {buildHelpLoaderStatements} = require('./help-system/entry')
-
-/**
- * Handles an 
- * @param {string} componentName - the name of the component definition
- * @param {string} html - The html string.
- * @param {*} path - the babel AST path
- */
-const handleHtml = (componentName, html, path) => {
-  return generateStatements(componentName, html, false, path)
-}
-
-
-const handleStubs = (componentName, stubs, path) => {
-  const statements = []
-  for (const [stubName, stubHtml] of Object.entries(stubs)) {
-    let anonymousCls = path.scope.generateUidIdentifier("sv").name
-    statements.push(`var ${anonymousCls} = ${componentName}.prototype.__sv();`)
-    statements.push(`${componentName}.prototype.__stubs__${stubName} = ${anonymousCls};`)
-    generateStatements(anonymousCls, stubHtml, true, path).forEach(statement => {
-      statements.push(statement)
-    })
-  }
-  return statements
-}
-
-
-const generateStatements = (className, html, processAsStub, path) => {
-  let statements
-  try {
-    const builder = new CodeGenerator(className, html, processAsStub, path)
-    statements = builder.buildStatements()
-  } catch (error) {
-    if (error instanceof RequestsHelp) {
-      return buildHelpLoaderStatements(error.topic)
-    } else if (error instanceof FrameworkError) {
-      const bar = '|'
-      const hr =     '|----------------------------------------------------------------------'
-      const header = '|  Error in component definition (specific location not available yet).'
-      const errorMessage = `${bar}  > ${error.msg}`
-      const fullMessage = ['\n', hr, bar, header, bar, errorMessage, bar, hr].join('\n')
-      throw path.buildCodeFrameError(fullMessage)
-    } else {
-      throw error
-    }
-  }
-  return statements
-}
-
-module.exports = {handleHtml, handleStubs}

package/lib_old/index.js

@@ -1,145 +0,0 @@
-const t = require('@babel/types')
-const {handleHtml, handleStubs} = require('./handlers')
-const {
-  getNodeHtmlString, 
-  getNodeHtmlObjectOfStrings, 
-  insertStatementsAfter, 
-  removeWallaceDefs
-} = require('./utils/babel')
-
-
-module.exports = () => {
-  return {
-    visitor: {
-      MemberExpression(path) {
-        /* This just replaces this:
-          
-            const Button = Foo.__ex__(
-          
-          with:
-
-            const Button = Foo.prototype.__ex(
-              
-        But it also seems to be handled further down?
-        Can this be merged into CallExpression?
-        */
-        if (path.node.property.name === '__ex__') {
-          const baseClass = path.node.object.name
-          path.replaceWithSourceString(`${baseClass}.prototype.__ex`)
-        }
-      },
-      CallExpression(path) {
-        const callee = path.node.callee
-        if (
-          callee &&
-          callee.type === 'MemberExpression' && 
-          callee.property.name === '__ex__' &&
-          path.parent &&
-          path.parent.type === 'VariableDeclarator'
-          ) {
-                  
-          const baseClass = callee.object.name
-          const componentName = path.parent.id.name
-          const nodeToInsertAfter = path.parentPath.parentPath
-          const data = parseExArguments(path)
-
-          // data seems to have [stubs, html, constructor, prototype] - but do we want 
-          // to allows all of those?
-
-          if (data.html) {
-            let statements = handleHtml(componentName, getNodeHtmlString(data.html), path)
-            insertStatementsAfter(nodeToInsertAfter, statements)
-          }
-
-          if (data.stubs) {
-            let statements = handleStubs(componentName, getNodeHtmlObjectOfStrings(data.stubs), path)
-            insertStatementsAfter(nodeToInsertAfter, statements)
-          }
-          
-          const newArgs = [t.identifier(baseClass)]
-          
-          // If either is supplied, we must still include both arguments to the call.
-          let protoArg, constructorArg
-          if (data.hasOwnProperty('prototype')) {
-            protoArg = data.prototype
-          }
-          if (data.hasOwnProperty('constructor')) {
-            constructorArg = data.constructor
-          }
-          if (protoArg || constructorArg) {
-            newArgs.push(protoArg || t.identifier('undefined'))
-            newArgs.push(constructorArg)
-          }
-          path.node.arguments = newArgs
-        }
-      },
-      Class(path, state) {
-        if (path.type === 'ClassDeclaration') {
-
-          // TODO: tidy up how args are passed, and whether we bother with componentData...
-          let html, stubs, componentName = path.node.id.name
-
-          // Iterate over class nodes to find ones we care about
-          for (let node of path.node.body.body) {
-            let propName = node.key.name
-            if (propName === '__html__' || propName === '__clone__') {
-              html = getNodeHtmlString(node.value)
-            } else if (propName === '__stubs__') {
-              stubs = getNodeHtmlObjectOfStrings(node.value)
-            }
-          }
-          removeWallaceDefs(path)
-          if (stubs) {
-            insertStatementsAfter(path, handleStubs(componentName, stubs, path))
-          }
-          if (html) {
-            insertStatementsAfter(path, handleHtml(componentName, html, path))
-          }
-        }
-      },
-    }
-  }
-}
-
-
-const allowedHtmlTypes = [
-  'TaggedTemplateExpression',
-  'TemplateLiteral',
-  'StringLiteral',
-  'JSXElement'
-]
-const eitherAllowedTypes = [...allowedHtmlTypes, 'ObjectExpression']
-
-const assertType = (path, thing, types, description) => {
-  if (!types.includes(thing.type)) {
-    throw path.buildCodeFrameError(`${description} must be of type ${types} but is a ${thing.type}.`)
-  }
-  return thing
-}
-
-const parseExArguments = (path) => {
-  const args = path.node.arguments
-  const data = {}
-
-  if (args.length == 1) {
-    // Must be html or an ObjectExpression - not an identifier
-    const argument = assertType(path, args[0], eitherAllowedTypes, 'Argument to __ex__()')
-    if (argument.type == 'ObjectExpression') {
-      argument.properties.forEach(element => {
-
-        // Does this get "stubs"?
-        data[element.key.name] = element.value
-      })
-    } else {
-      data['html'] = assertType(path, args[0], allowedHtmlTypes, 'Argument to __ex__()')
-    }
-  } else if (args.length == 2) {
-    // Must be __ex__(html, methods) where methods can be an object literal or an identifier.
-
-    data['html'] = assertType(path, args[0], allowedHtmlTypes, 'First Argument to __ex__()')
-    data['prototype'] = assertType(path, args[1], ['ObjectExpression', 'Identifier'], 'Second Argument to __ex__()')
-  } else {
-    throw path.buildCodeFrameError(`__ex__() takes either one or two arguments, Received ${args.length}.`)
-  }
-  return data
-}