@domql/globusa 3.7.6

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@domql/globusa",
+  "version": "3.7.6",
+  "description": "Handle global scope in domql components",
+  "scripts": {
+    "build": "node ./esbuild-globusa.js",
+    "test": "cd tests && bash run-tests.sh"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "main": "dist/index.cjs",
+  "source": "src/index.js",
+  "exports": {
+    ".": {
+      "default": "./dist/index.cjs"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@babel/core": "^7.22.8",
+    "@babel/parser": "^7.22.7",
+    "@babel/traverse": "^7.22.8",
+    "@babel/types": "^7.22.5",
+    "stringify-object-extract-functions": "^2.4.1"
+  },
+  "devDependencies": {
+    "esbuild": "^0.18.11"
+  }
+}

package/src/index.js

@@ -0,0 +1,117 @@
+import stringify from './stringify'
+import { parse as babelParse } from '@babel/parser'
+import babelTraverse from '@babel/traverse'
+import * as types from '@babel/types'
+
+function handleImportDeclaration(code, node) {
+  const importObj = {
+    imports: {},
+    path: node.source.value,
+  }
+
+  for (const s of node.specifiers) {
+    let importName, varName;
+    if (types.isImportDefaultSpecifier(s)) {
+      importName = 'default'
+      varName = s.local.name
+    } else if (types.isImportNamespaceSpecifier(s)) {
+      importName = '*'
+      varName = s.local.name
+    } else {
+      importName = s.imported.name
+      varName = s.local.name
+    }
+    importObj.imports[varName] = importName
+  }
+
+  return importObj
+}
+
+export function parse(code) {
+  const globusaObj = {
+    // Array of mitosis-style import structures
+    imports: [],
+
+    // Array of lines of code (strings)  which are part of export statements
+    exports: [],
+
+    // Any line of code that's not an import or an export. (Array of strings).
+    declarations: [],
+
+    // Any line of code that's not part of an 'import' statement
+    linesExcludingImports: [],
+
+    // Array of strings which are parts of a domql component
+    domqlComponents: [],
+
+    // Array of strings of identifiers declared in the code
+    identifiers: []
+  }
+
+  const codeAST = babelParse(code, { sourceType: "module", plugins: ["jsx"] })
+
+  babelTraverse(codeAST, {
+    enter(path) {
+      if (path.isImportDeclaration()) {
+        const mitosisImportDecl = handleImportDeclaration(code, path.node)
+        globusaObj.imports.push(mitosisImportDecl)
+        path.skip()
+      } else if (path.isExportDeclaration()) {
+        const codeStr = code.substring(path.node.start, path.node.end)
+        globusaObj.exports.push(codeStr)
+        globusaObj.linesExcludingImports.push(codeStr)
+
+        // Extract the domql component
+        const decl = path.node.declaration
+        if (decl && decl.declarations) {
+          for (const d of decl.declarations) {
+            const compo = { name: null, code: "" }
+
+            // Extract component name
+            if (d.id && types.isIdentifier(d.id) && d.id.name) {
+              compo.name = d.id.name
+
+              // Also save the variable name in identifiers
+              if (types.isProgram(path.parent))
+                globusaObj.identifiers.push(d.id.name)
+            }
+
+            // Extract object expression
+            if (d.init && types.isObjectExpression(d.init)) {
+              compo.code = code.substring(d.init.start, d.init.end)
+            }
+
+            globusaObj.domqlComponents.push(compo)
+          }
+        }
+
+        path.skip()
+      } else if (path.isVariableDeclaration() && types.isProgram(path.parent)) {
+          for (const decl of path.node.declarations) {
+            if (decl && decl.id && decl.id.name)
+              globusaObj.identifiers.push(decl.id.name)
+          }
+      } else if (path.isFunctionDeclaration() && types.isProgram(path.parent)) {
+        const decl = path.node
+        if (decl.id && decl.id.name)
+          globusaObj.identifiers.push(decl.id.name)
+      }
+
+      if (!path.isProgram() && !path.isImportDeclaration() &&
+          !path.isExportDeclaration()) {
+        // Skip directives like 'use strict'
+        if (path.isDirective()) {
+          path.skip()
+          return;
+        }
+
+        const codeStr = code.substring(path.node.start, path.node.end)
+        globusaObj.declarations.push(codeStr)
+        globusaObj.linesExcludingImports.push(codeStr)
+        path.skip()
+      }
+    }
+  })
+
+  return globusaObj
+}

package/src/stringify.js

@@ -0,0 +1,27 @@
+import stringifyObject from 'stringify-object-extract-functions'
+
+function genSpaces(num) {
+  if (!num || num < 1) return ''
+  let str = ''
+  for (let i = 0; i < num; i++)
+    str = str + ' '
+  return str
+}
+
+// Equivalent to 'JSON.stringify', but also stringifies functions
+export default function stringify(a, indentWidth) {
+  if (typeof a === 'function' || typeof a === 'number')
+    return a.toString()
+
+  const str = stringifyObject(a, {
+    indent: genSpaces(indentWidth),
+    inlineCharacterLimit: 24
+  })
+
+  if (str[str.length - 2] === '\n') {
+    // Correctly indent trailing char (either '}' or ']')
+    return str.slice(0, str.length - 1) + genSpaces(indentWidth - 2) + str.slice(-1)
+  }
+
+  return str
+}

package/src/testcode.js

@@ -0,0 +1,21 @@
+export const testcode = `
+import { downcase } from 'downcase';
+import { upcase } from 'upcase';
+
+import Preact from 'preact';
+import * as MathFunctions from 'math';
+import React, { utils as reactUtils } from 'react';
+
+import emotion, {
+  setClassName as scn,
+  doTheThing as dtt,
+  evaluate } from '@emotion/css';
+
+const privateFunction = (x) => x * 2
+
+export const RandomComponentName = {
+  tag: 'div',
+  p: () => upcase('hello, friends!'),
+  on: { click: (ev, el) => console.log(privateFunction(el.props.x)) },
+  props: { x: 12 }
+}`