ether-code 0.1.6 → 0.1.8

package/parsers/ast-react.js

@@ -1,580 +0,0 @@
-const JSAST = require('./ast-js')
-
-class JSXElement extends JSAST.ASTNode {
-    constructor(openingElement, closingElement = null, children = [], loc = null) {
-        super('JSXElement', loc)
-        this.openingElement = openingElement
-        this.closingElement = closingElement
-        this.children = children
-    }
-}
-
-class JSXOpeningElement extends JSAST.ASTNode {
-    constructor(name, attributes = [], selfClosing = false, loc = null) {
-        super('JSXOpeningElement', loc)
-        this.name = name
-        this.attributes = attributes
-        this.selfClosing = selfClosing
-    }
-}
-
-class JSXClosingElement extends JSAST.ASTNode {
-    constructor(name, loc = null) {
-        super('JSXClosingElement', loc)
-        this.name = name
-    }
-}
-
-class JSXFragment extends JSAST.ASTNode {
-    constructor(openingFragment, closingFragment, children = [], loc = null) {
-        super('JSXFragment', loc)
-        this.openingFragment = openingFragment
-        this.closingFragment = closingFragment
-        this.children = children
-    }
-}
-
-class JSXOpeningFragment extends JSAST.ASTNode {
-    constructor(loc = null) {
-        super('JSXOpeningFragment', loc)
-    }
-}
-
-class JSXClosingFragment extends JSAST.ASTNode {
-    constructor(loc = null) {
-        super('JSXClosingFragment', loc)
-    }
-}
-
-class JSXIdentifier extends JSAST.ASTNode {
-    constructor(name, loc = null) {
-        super('JSXIdentifier', loc)
-        this.name = name
-    }
-}
-
-class JSXMemberExpression extends JSAST.ASTNode {
-    constructor(object, property, loc = null) {
-        super('JSXMemberExpression', loc)
-        this.object = object
-        this.property = property
-    }
-}
-
-class JSXNamespacedName extends JSAST.ASTNode {
-    constructor(namespace, name, loc = null) {
-        super('JSXNamespacedName', loc)
-        this.namespace = namespace
-        this.name = name
-    }
-}
-
-class JSXAttribute extends JSAST.ASTNode {
-    constructor(name, value = null, loc = null) {
-        super('JSXAttribute', loc)
-        this.name = name
-        this.value = value
-    }
-}
-
-class JSXSpreadAttribute extends JSAST.ASTNode {
-    constructor(argument, loc = null) {
-        super('JSXSpreadAttribute', loc)
-        this.argument = argument
-    }
-}
-
-class JSXText extends JSAST.ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('JSXText', loc)
-        this.value = value
-        this.raw = raw || value
-    }
-}
-
-class JSXExpressionContainer extends JSAST.ASTNode {
-    constructor(expression, loc = null) {
-        super('JSXExpressionContainer', loc)
-        this.expression = expression
-    }
-}
-
-class JSXSpreadChild extends JSAST.ASTNode {
-    constructor(expression, loc = null) {
-        super('JSXSpreadChild', loc)
-        this.expression = expression
-    }
-}
-
-class JSXEmptyExpression extends JSAST.ASTNode {
-    constructor(loc = null) {
-        super('JSXEmptyExpression', loc)
-    }
-}
-
-class ReactComponent extends JSAST.ASTNode {
-    constructor(name, type = 'function', props = [], body = null, loc = null) {
-        super('ReactComponent', loc)
-        this.name = name
-        this.componentType = type
-        this.props = props
-        this.body = body
-    }
-}
-
-class ReactHookCall extends JSAST.ASTNode {
-    constructor(hookName, arguments_ = [], loc = null) {
-        super('ReactHookCall', loc)
-        this.hookName = hookName
-        this.arguments = arguments_
-    }
-}
-
-class UseStateHook extends JSAST.ASTNode {
-    constructor(stateName, setterName, initialValue = null, loc = null) {
-        super('UseStateHook', loc)
-        this.stateName = stateName
-        this.setterName = setterName
-        this.initialValue = initialValue
-    }
-}
-
-class UseEffectHook extends JSAST.ASTNode {
-    constructor(callback, dependencies = null, loc = null) {
-        super('UseEffectHook', loc)
-        this.callback = callback
-        this.dependencies = dependencies
-    }
-}
-
-class UseRefHook extends JSAST.ASTNode {
-    constructor(refName, initialValue = null, loc = null) {
-        super('UseRefHook', loc)
-        this.refName = refName
-        this.initialValue = initialValue
-    }
-}
-
-class UseContextHook extends JSAST.ASTNode {
-    constructor(context, loc = null) {
-        super('UseContextHook', loc)
-        this.context = context
-    }
-}
-
-class UseReducerHook extends JSAST.ASTNode {
-    constructor(stateName, dispatchName, reducer, initialState, loc = null) {
-        super('UseReducerHook', loc)
-        this.stateName = stateName
-        this.dispatchName = dispatchName
-        this.reducer = reducer
-        this.initialState = initialState
-    }
-}
-
-class UseMemoHook extends JSAST.ASTNode {
-    constructor(factory, dependencies = [], loc = null) {
-        super('UseMemoHook', loc)
-        this.factory = factory
-        this.dependencies = dependencies
-    }
-}
-
-class UseCallbackHook extends JSAST.ASTNode {
-    constructor(callback, dependencies = [], loc = null) {
-        super('UseCallbackHook', loc)
-        this.callback = callback
-        this.dependencies = dependencies
-    }
-}
-
-class UseTransitionHook extends JSAST.ASTNode {
-    constructor(isPendingName, startTransitionName, loc = null) {
-        super('UseTransitionHook', loc)
-        this.isPendingName = isPendingName
-        this.startTransitionName = startTransitionName
-    }
-}
-
-class UseDeferredValueHook extends JSAST.ASTNode {
-    constructor(value, loc = null) {
-        super('UseDeferredValueHook', loc)
-        this.value = value
-    }
-}
-
-class UseIdHook extends JSAST.ASTNode {
-    constructor(idName, loc = null) {
-        super('UseIdHook', loc)
-        this.idName = idName
-    }
-}
-
-class UseImperativeHandleHook extends JSAST.ASTNode {
-    constructor(ref, createHandle, dependencies = null, loc = null) {
-        super('UseImperativeHandleHook', loc)
-        this.ref = ref
-        this.createHandle = createHandle
-        this.dependencies = dependencies
-    }
-}
-
-class UseLayoutEffectHook extends JSAST.ASTNode {
-    constructor(callback, dependencies = null, loc = null) {
-        super('UseLayoutEffectHook', loc)
-        this.callback = callback
-        this.dependencies = dependencies
-    }
-}
-
-class UseInsertionEffectHook extends JSAST.ASTNode {
-    constructor(callback, dependencies = null, loc = null) {
-        super('UseInsertionEffectHook', loc)
-        this.callback = callback
-        this.dependencies = dependencies
-    }
-}
-
-class UseSyncExternalStoreHook extends JSAST.ASTNode {
-    constructor(subscribe, getSnapshot, getServerSnapshot = null, loc = null) {
-        super('UseSyncExternalStoreHook', loc)
-        this.subscribe = subscribe
-        this.getSnapshot = getSnapshot
-        this.getServerSnapshot = getServerSnapshot
-    }
-}
-
-class UseDebugValueHook extends JSAST.ASTNode {
-    constructor(value, formatter = null, loc = null) {
-        super('UseDebugValueHook', loc)
-        this.value = value
-        this.formatter = formatter
-    }
-}
-
-class UseActionStateHook extends JSAST.ASTNode {
-    constructor(stateName, actionName, action, initialState, permalink = null, loc = null) {
-        super('UseActionStateHook', loc)
-        this.stateName = stateName
-        this.actionName = actionName
-        this.action = action
-        this.initialState = initialState
-        this.permalink = permalink
-    }
-}
-
-class UseFormStatusHook extends JSAST.ASTNode {
-    constructor(loc = null) {
-        super('UseFormStatusHook', loc)
-    }
-}
-
-class UseOptimisticHook extends JSAST.ASTNode {
-    constructor(optimisticName, setOptimisticName, state, updateFn, loc = null) {
-        super('UseOptimisticHook', loc)
-        this.optimisticName = optimisticName
-        this.setOptimisticName = setOptimisticName
-        this.state = state
-        this.updateFn = updateFn
-    }
-}
-
-class UseHook extends JSAST.ASTNode {
-    constructor(resource, loc = null) {
-        super('UseHook', loc)
-        this.resource = resource
-    }
-}
-
-class ReactDirective extends JSAST.ASTNode {
-    constructor(directive, loc = null) {
-        super('ReactDirective', loc)
-        this.directive = directive
-    }
-}
-
-class CreateContextCall extends JSAST.ASTNode {
-    constructor(defaultValue = null, loc = null) {
-        super('CreateContextCall', loc)
-        this.defaultValue = defaultValue
-    }
-}
-
-class ContextProvider extends JSAST.ASTNode {
-    constructor(context, value, children = [], loc = null) {
-        super('ContextProvider', loc)
-        this.context = context
-        this.value = value
-        this.children = children
-    }
-}
-
-class ContextConsumer extends JSAST.ASTNode {
-    constructor(context, children, loc = null) {
-        super('ContextConsumer', loc)
-        this.context = context
-        this.children = children
-    }
-}
-
-class ForwardRefCall extends JSAST.ASTNode {
-    constructor(render, loc = null) {
-        super('ForwardRefCall', loc)
-        this.render = render
-    }
-}
-
-class MemoCall extends JSAST.ASTNode {
-    constructor(component, areEqual = null, loc = null) {
-        super('MemoCall', loc)
-        this.component = component
-        this.areEqual = areEqual
-    }
-}
-
-class LazyCall extends JSAST.ASTNode {
-    constructor(load, loc = null) {
-        super('LazyCall', loc)
-        this.load = load
-    }
-}
-
-class SuspenseComponent extends JSAST.ASTNode {
-    constructor(fallback, children = [], loc = null) {
-        super('SuspenseComponent', loc)
-        this.fallback = fallback
-        this.children = children
-    }
-}
-
-class StrictModeComponent extends JSAST.ASTNode {
-    constructor(children = [], loc = null) {
-        super('StrictModeComponent', loc)
-        this.children = children
-    }
-}
-
-class ProfilerComponent extends JSAST.ASTNode {
-    constructor(id, onRender, children = [], loc = null) {
-        super('ProfilerComponent', loc)
-        this.id = id
-        this.onRender = onRender
-        this.children = children
-    }
-}
-
-class ErrorBoundary extends JSAST.ASTNode {
-    constructor(fallback, onError = null, children = [], loc = null) {
-        super('ErrorBoundary', loc)
-        this.fallback = fallback
-        this.onError = onError
-        this.children = children
-    }
-}
-
-class CreatePortalCall extends JSAST.ASTNode {
-    constructor(children, container, key = null, loc = null) {
-        super('CreatePortalCall', loc)
-        this.children = children
-        this.container = container
-        this.key = key
-    }
-}
-
-class CreateRootCall extends JSAST.ASTNode {
-    constructor(container, options = null, loc = null) {
-        super('CreateRootCall', loc)
-        this.container = container
-        this.options = options
-    }
-}
-
-class HydrateRootCall extends JSAST.ASTNode {
-    constructor(container, initialChildren, options = null, loc = null) {
-        super('HydrateRootCall', loc)
-        this.container = container
-        this.initialChildren = initialChildren
-        this.options = options
-    }
-}
-
-class StartTransitionCall extends JSAST.ASTNode {
-    constructor(callback, loc = null) {
-        super('StartTransitionCall', loc)
-        this.callback = callback
-    }
-}
-
-class FlushSyncCall extends JSAST.ASTNode {
-    constructor(callback, loc = null) {
-        super('FlushSyncCall', loc)
-        this.callback = callback
-    }
-}
-
-class CreateElementCall extends JSAST.ASTNode {
-    constructor(type, props = null, children = [], loc = null) {
-        super('CreateElementCall', loc)
-        this.elementType = type
-        this.props = props
-        this.children = children
-    }
-}
-
-class CloneElementCall extends JSAST.ASTNode {
-    constructor(element, props = null, children = [], loc = null) {
-        super('CloneElementCall', loc)
-        this.element = element
-        this.props = props
-        this.children = children
-    }
-}
-
-class IsValidElementCall extends JSAST.ASTNode {
-    constructor(object, loc = null) {
-        super('IsValidElementCall', loc)
-        this.object = object
-    }
-}
-
-class ChildrenMapCall extends JSAST.ASTNode {
-    constructor(children, fn, thisArg = null, loc = null) {
-        super('ChildrenMapCall', loc)
-        this.children = children
-        this.fn = fn
-        this.thisArg = thisArg
-    }
-}
-
-class ChildrenForEachCall extends JSAST.ASTNode {
-    constructor(children, fn, thisArg = null, loc = null) {
-        super('ChildrenForEachCall', loc)
-        this.children = children
-        this.fn = fn
-        this.thisArg = thisArg
-    }
-}
-
-class ChildrenCountCall extends JSAST.ASTNode {
-    constructor(children, loc = null) {
-        super('ChildrenCountCall', loc)
-        this.children = children
-    }
-}
-
-class ChildrenOnlyCall extends JSAST.ASTNode {
-    constructor(children, loc = null) {
-        super('ChildrenOnlyCall', loc)
-        this.children = children
-    }
-}
-
-class ChildrenToArrayCall extends JSAST.ASTNode {
-    constructor(children, loc = null) {
-        super('ChildrenToArrayCall', loc)
-        this.children = children
-    }
-}
-
-class ServerActionFunction extends JSAST.ASTNode {
-    constructor(name, params = [], body, loc = null) {
-        super('ServerActionFunction', loc)
-        this.name = name
-        this.params = params
-        this.body = body
-    }
-}
-
-class FormActionAttribute extends JSAST.ASTNode {
-    constructor(action, loc = null) {
-        super('FormActionAttribute', loc)
-        this.action = action
-    }
-}
-
-class EtherReactComponent extends JSAST.ASTNode {
-    constructor(name, props = [], returnJSX, hooks = [], loc = null) {
-        super('EtherReactComponent', loc)
-        this.name = name
-        this.props = props
-        this.returnJSX = returnJSX
-        this.hooks = hooks
-    }
-}
-
-class EtherHookDeclaration extends JSAST.ASTNode {
-    constructor(hookType, bindings = [], arguments_ = [], loc = null) {
-        super('EtherHookDeclaration', loc)
-        this.hookType = hookType
-        this.bindings = bindings
-        this.arguments = arguments_
-    }
-}
-
-module.exports = {
-    ...JSAST,
-    JSXElement,
-    JSXOpeningElement,
-    JSXClosingElement,
-    JSXFragment,
-    JSXOpeningFragment,
-    JSXClosingFragment,
-    JSXIdentifier,
-    JSXMemberExpression,
-    JSXNamespacedName,
-    JSXAttribute,
-    JSXSpreadAttribute,
-    JSXText,
-    JSXExpressionContainer,
-    JSXSpreadChild,
-    JSXEmptyExpression,
-    ReactComponent,
-    ReactHookCall,
-    UseStateHook,
-    UseEffectHook,
-    UseRefHook,
-    UseContextHook,
-    UseReducerHook,
-    UseMemoHook,
-    UseCallbackHook,
-    UseTransitionHook,
-    UseDeferredValueHook,
-    UseIdHook,
-    UseImperativeHandleHook,
-    UseLayoutEffectHook,
-    UseInsertionEffectHook,
-    UseSyncExternalStoreHook,
-    UseDebugValueHook,
-    UseActionStateHook,
-    UseFormStatusHook,
-    UseOptimisticHook,
-    UseHook,
-    ReactDirective,
-    CreateContextCall,
-    ContextProvider,
-    ContextConsumer,
-    ForwardRefCall,
-    MemoCall,
-    LazyCall,
-    SuspenseComponent,
-    StrictModeComponent,
-    ProfilerComponent,
-    ErrorBoundary,
-    CreatePortalCall,
-    CreateRootCall,
-    HydrateRootCall,
-    StartTransitionCall,
-    FlushSyncCall,
-    CreateElementCall,
-    CloneElementCall,
-    IsValidElementCall,
-    ChildrenMapCall,
-    ChildrenForEachCall,
-    ChildrenCountCall,
-    ChildrenOnlyCall,
-    ChildrenToArrayCall,
-    ServerActionFunction,
-    FormActionAttribute,
-    EtherReactComponent,
-    EtherHookDeclaration
-}