@vue-jsx-vapor/compiler 0.0.2 → 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,368 @@
+import { IRFor as IRFor$1, VaporCodegenResult as VaporCodegenResult$1 } from '@vue/compiler-vapor';
+export { generate } from '@vue/compiler-vapor';
+import { SimpleExpressionNode, BindingTypes, DirectiveNode, CompoundExpressionNode, TransformOptions as TransformOptions$1, CompilerCompatOptions, CommentNode, CompilerOptions as CompilerOptions$1, ElementNode } from '@vue/compiler-dom';
+import * as _vue_runtime_vapor from '@vue/runtime-vapor';
+import { JSXFragment, Node, JSXAttribute, JSXElement, Program } from '@babel/types';
+import { Prettify } from '@vue/shared';
+
+interface IRProp extends Omit<DirectiveTransformResult, 'value'> {
+    values: SimpleExpressionNode[];
+}
+declare enum IRDynamicPropsKind {
+    EXPRESSION = 0,// v-bind="value"
+    ATTRIBUTE = 1
+}
+type IRPropsStatic = IRProp[];
+interface IRPropsDynamicExpression {
+    kind: IRDynamicPropsKind.EXPRESSION;
+    value: SimpleExpressionNode;
+    handler?: boolean;
+}
+interface IRPropsDynamicAttribute extends IRProp {
+    kind: IRDynamicPropsKind.ATTRIBUTE;
+}
+type IRProps = IRPropsStatic | IRPropsDynamicAttribute | IRPropsDynamicExpression;
+interface SlotBlockIRNode extends BlockIRNode {
+    props?: SimpleExpressionNode;
+}
+declare enum IRSlotType {
+    STATIC = 0,
+    DYNAMIC = 1,
+    LOOP = 2,
+    CONDITIONAL = 3,
+    EXPRESSION = 4
+}
+interface IRSlotsStatic {
+    slotType: IRSlotType.STATIC;
+    slots: Record<string, SlotBlockIRNode>;
+}
+interface IRSlotDynamicBasic {
+    slotType: IRSlotType.DYNAMIC;
+    name: SimpleExpressionNode;
+    fn: SlotBlockIRNode;
+}
+interface IRSlotDynamicLoop {
+    slotType: IRSlotType.LOOP;
+    name: SimpleExpressionNode;
+    fn: SlotBlockIRNode;
+    loop: IRFor$1;
+}
+interface IRSlotDynamicConditional {
+    slotType: IRSlotType.CONDITIONAL;
+    condition: SimpleExpressionNode;
+    positive: IRSlotDynamicBasic;
+    negative?: IRSlotDynamicBasic | IRSlotDynamicConditional;
+}
+interface IRSlotsExpression {
+    slotType: IRSlotType.EXPRESSION;
+    slots: SimpleExpressionNode;
+}
+type IRSlotDynamic = IRSlotDynamicBasic | IRSlotDynamicLoop | IRSlotDynamicConditional;
+type IRSlots = IRSlotsStatic | IRSlotDynamic | IRSlotsExpression;
+
+declare enum IRNodeTypes {
+    ROOT = 0,
+    BLOCK = 1,
+    SET_PROP = 2,
+    SET_DYNAMIC_PROPS = 3,
+    SET_TEXT = 4,
+    SET_EVENT = 5,
+    SET_DYNAMIC_EVENTS = 6,
+    SET_HTML = 7,
+    SET_TEMPLATE_REF = 8,
+    SET_MODEL_VALUE = 9,
+    SET_INHERIT_ATTRS = 10,
+    INSERT_NODE = 11,
+    PREPEND_NODE = 12,
+    CREATE_TEXT_NODE = 13,
+    CREATE_COMPONENT_NODE = 14,
+    SLOT_OUTLET_NODE = 15,
+    WITH_DIRECTIVE = 16,
+    DECLARE_OLD_REF = 17,// consider make it more general
+    IF = 18,
+    FOR = 19
+}
+interface BaseIRNode {
+    type: IRNodeTypes;
+}
+type VaporHelper = keyof typeof _vue_runtime_vapor;
+interface RootNode {
+    type: IRNodeTypes.ROOT;
+    source: string;
+    children: JSXFragment['children'];
+    helpers: Set<symbol>;
+    components: string[];
+    directives: string[];
+    temps: number;
+    ssrHelpers?: symbol[];
+    transformed?: boolean;
+}
+interface BlockIRNode extends BaseIRNode {
+    type: IRNodeTypes.BLOCK;
+    node: RootNode | Node;
+    dynamic: IRDynamicInfo;
+    effect: IREffect[];
+    operation: OperationNode[];
+    returns: number[];
+}
+interface RootIRNode {
+    type: IRNodeTypes.ROOT;
+    node: RootNode;
+    source: string;
+    template: string[];
+    component: Set<string>;
+    directive: Set<string>;
+    block: BlockIRNode;
+}
+interface IfIRNode extends BaseIRNode {
+    type: IRNodeTypes.IF;
+    id: number;
+    condition: SimpleExpressionNode;
+    positive: BlockIRNode;
+    negative?: BlockIRNode | IfIRNode;
+    once?: boolean;
+}
+interface IRFor {
+    source: SimpleExpressionNode;
+    value?: SimpleExpressionNode;
+    key?: SimpleExpressionNode;
+    index?: SimpleExpressionNode;
+}
+interface ForIRNode extends BaseIRNode, IRFor {
+    type: IRNodeTypes.FOR;
+    id: number;
+    keyProp?: SimpleExpressionNode;
+    render: BlockIRNode;
+    once: boolean;
+    container?: number;
+}
+interface SetPropIRNode extends BaseIRNode {
+    type: IRNodeTypes.SET_PROP;
+    element: number;
+    prop: IRProp;
+    root: boolean;
+    tag: string;
+}
+interface SetDynamicPropsIRNode extends BaseIRNode {
+    type: IRNodeTypes.SET_DYNAMIC_PROPS;
+    element: number;
+    props: IRProps[];
+    root: boolean;
+}
+interface SetDynamicEventsIRNode extends BaseIRNode {
+    type: IRNodeTypes.SET_DYNAMIC_EVENTS;
+    element: number;
+    event: SimpleExpressionNode;
+}
+interface SetTextIRNode extends BaseIRNode {
+    type: IRNodeTypes.SET_TEXT;
+    element: number;
+    values: SimpleExpressionNode[];
+}
+type KeyOverride = [find: string, replacement: string];
+interface SetEventIRNode extends BaseIRNode {
+    type: IRNodeTypes.SET_EVENT;
+    element: number;
+    key: SimpleExpressionNode;
+    value?: SimpleExpressionNode;
+    modifiers: {
+        options: string[];
+        keys: string[];
+        nonKeys: string[];
+    };
+    keyOverride?: KeyOverride;
+    delegate: boolean;
+    /** Whether it's in effect */
+    effect: boolean;
+}
+interface SetHtmlIRNode extends BaseIRNode {
+    type: IRNodeTypes.SET_HTML;
+    element: number;
+    value: SimpleExpressionNode;
+}
+interface SetTemplateRefIRNode extends BaseIRNode {
+    type: IRNodeTypes.SET_TEMPLATE_REF;
+    element: number;
+    value: SimpleExpressionNode;
+    refFor: boolean;
+    effect: boolean;
+}
+interface SetModelValueIRNode extends BaseIRNode {
+    type: IRNodeTypes.SET_MODEL_VALUE;
+    element: number;
+    key: SimpleExpressionNode;
+    value: SimpleExpressionNode;
+    bindingType?: BindingTypes;
+    isComponent: boolean;
+}
+interface SetInheritAttrsIRNode extends BaseIRNode {
+    type: IRNodeTypes.SET_INHERIT_ATTRS;
+    staticProps: boolean;
+    dynamicProps: true | string[];
+}
+interface CreateTextNodeIRNode extends BaseIRNode {
+    type: IRNodeTypes.CREATE_TEXT_NODE;
+    id: number;
+    values: SimpleExpressionNode[];
+    effect: boolean;
+}
+interface InsertNodeIRNode extends BaseIRNode {
+    type: IRNodeTypes.INSERT_NODE;
+    elements: number[];
+    parent: number;
+    anchor?: number;
+}
+interface PrependNodeIRNode extends BaseIRNode {
+    type: IRNodeTypes.PREPEND_NODE;
+    elements: number[];
+    parent: number;
+}
+interface WithDirectiveIRNode extends BaseIRNode {
+    type: IRNodeTypes.WITH_DIRECTIVE;
+    element: number;
+    dir: VaporDirectiveNode;
+    name: string;
+    builtin?: boolean;
+    asset?: boolean;
+}
+interface CreateComponentIRNode extends BaseIRNode {
+    type: IRNodeTypes.CREATE_COMPONENT_NODE;
+    id: number;
+    tag: string;
+    props: IRProps[];
+    slots: IRSlots[];
+    asset: boolean;
+    root: boolean;
+    once: boolean;
+}
+interface DeclareOldRefIRNode extends BaseIRNode {
+    type: IRNodeTypes.DECLARE_OLD_REF;
+    id: number;
+}
+interface SlotOutletIRNode extends BaseIRNode {
+    type: IRNodeTypes.SLOT_OUTLET_NODE;
+    id: number;
+    name: SimpleExpressionNode;
+    props: IRProps[];
+    fallback?: BlockIRNode;
+}
+type IRNode = OperationNode | RootIRNode;
+type OperationNode = SetPropIRNode | SetDynamicPropsIRNode | SetTextIRNode | SetEventIRNode | SetDynamicEventsIRNode | SetHtmlIRNode | SetTemplateRefIRNode | SetModelValueIRNode | SetInheritAttrsIRNode | CreateTextNodeIRNode | InsertNodeIRNode | PrependNodeIRNode | WithDirectiveIRNode | IfIRNode | ForIRNode | CreateComponentIRNode | DeclareOldRefIRNode | SlotOutletIRNode;
+declare enum DynamicFlag {
+    NONE = 0,
+    /**
+     * This node is referenced and needs to be saved as a variable.
+     */
+    REFERENCED = 1,
+    /**
+     * This node is not generated from template, but is generated dynamically.
+     */
+    NON_TEMPLATE = 2,
+    /**
+     * This node needs to be inserted back into the template.
+     */
+    INSERT = 4
+}
+interface IRDynamicInfo {
+    id?: number;
+    flags: DynamicFlag;
+    anchor?: number;
+    children: IRDynamicInfo[];
+    template?: number;
+}
+interface IREffect {
+    expressions: SimpleExpressionNode[];
+    identifiers: string[];
+    operations: OperationNode[];
+    declareNames: Set<string>;
+    rewrittenNames: Set<string>;
+    earlyCheckExps: string[];
+    inVFor: boolean;
+}
+type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & Pick<U, Extract<keyof U, keyof T>>;
+type HackOptions<T> = Prettify<Overwrite<T, {
+    nodeTransforms?: NodeTransform[];
+    directiveTransforms?: Record<string, DirectiveTransform | undefined>;
+}>>;
+type VaporDirectiveNode = Overwrite<DirectiveNode, {
+    exp: Exclude<DirectiveNode['exp'], CompoundExpressionNode>;
+    arg: Exclude<DirectiveNode['arg'], CompoundExpressionNode>;
+}>;
+
+type NodeTransform = (node: BlockIRNode['node'], context: TransformContext<BlockIRNode['node']>) => void | (() => void) | (() => void)[];
+type DirectiveTransform = (dir: JSXAttribute, node: JSXElement, context: TransformContext<JSXElement>) => DirectiveTransformResult | void;
+interface DirectiveTransformResult {
+    key: SimpleExpressionNode;
+    value: SimpleExpressionNode;
+    modifier?: '.' | '^';
+    runtimeCamelize?: boolean;
+    handler?: boolean;
+    model?: boolean;
+    modelModifiers?: string[];
+}
+type TransformOptions = HackOptions<TransformOptions$1>;
+declare class TransformContext<T extends BlockIRNode['node'] = BlockIRNode['node']> {
+    ir: RootIRNode;
+    node: T;
+    parent: TransformContext<RootNode | JSXElement | JSXFragment> | null;
+    root: TransformContext<RootNode>;
+    index: number;
+    block: BlockIRNode;
+    options: Required<Omit<TransformOptions, 'filename' | keyof CompilerCompatOptions>>;
+    template: string;
+    childrenTemplate: (string | null)[];
+    dynamic: IRDynamicInfo;
+    inVOnce: boolean;
+    inVFor: number;
+    comment: CommentNode[];
+    component: Set<string>;
+    directive: Set<string>;
+    slots: IRSlots[];
+    private globalId;
+    constructor(ir: RootIRNode, node: T, options?: TransformOptions);
+    enterBlock(ir: BlockIRNode, isVFor?: boolean): () => void;
+    increaseId: () => number;
+    reference(): number;
+    pushTemplate(content: string): number;
+    registerTemplate(): number;
+    registerEffect(expressions: SimpleExpressionNode[], ...operations: OperationNode[]): void;
+    registerOperation(...node: OperationNode[]): void;
+    create<E extends T>(node: E, index: number): TransformContext<E>;
+}
+declare function transform(node: RootNode, options?: TransformOptions): RootIRNode;
+declare function transformNode(context: TransformContext<BlockIRNode['node']>): void;
+
+interface VaporCodegenResult extends Omit<VaporCodegenResult$1, 'ast'> {
+    ast: RootIRNode;
+}
+declare function compile(source: string | Program, options?: CompilerOptions): VaporCodegenResult;
+type CompilerOptions = HackOptions<CompilerOptions$1>;
+type TransformPreset = [
+    NodeTransform[],
+    Record<string, DirectiveTransform>
+];
+
+declare function resolveNode(node: JSXElement, context: TransformContext): ElementNode;
+declare function resolveDirectiveNode(node: JSXAttribute, context: TransformContext): VaporDirectiveNode;
+
+declare const transformText: NodeTransform;
+
+declare const transformElement: NodeTransform;
+
+declare const transformChildren: NodeTransform;
+
+declare const transformTemplateRef: NodeTransform;
+
+declare const transformVBind: DirectiveTransform;
+
+declare const transformVOn: DirectiveTransform;
+
+declare const transformVSlot: NodeTransform;
+
+declare const transformVModel: DirectiveTransform;
+
+declare const transformVShow: DirectiveTransform;
+
+declare const transformVHtml: DirectiveTransform;
+
+export { type BaseIRNode, type BlockIRNode, type CompilerOptions, type CreateComponentIRNode, type CreateTextNodeIRNode, type DeclareOldRefIRNode, type DirectiveTransform, type DirectiveTransformResult, DynamicFlag, type ForIRNode, type HackOptions, type IRDynamicInfo, IRDynamicPropsKind, type IREffect, type IRFor, type IRNode, IRNodeTypes, type IRProp, type IRProps, type IRPropsDynamicAttribute, type IRPropsDynamicExpression, type IRPropsStatic, type IRSlotDynamic, type IRSlotDynamicBasic, type IRSlotDynamicConditional, type IRSlotDynamicLoop, IRSlotType, type IRSlots, type IRSlotsExpression, type IRSlotsStatic, type IfIRNode, type InsertNodeIRNode, type KeyOverride, type NodeTransform, type OperationNode, type PrependNodeIRNode, type RootIRNode, type RootNode, type SetDynamicEventsIRNode, type SetDynamicPropsIRNode, type SetEventIRNode, type SetHtmlIRNode, type SetInheritAttrsIRNode, type SetModelValueIRNode, type SetPropIRNode, type SetTemplateRefIRNode, type SetTextIRNode, type SlotBlockIRNode, type SlotOutletIRNode, TransformContext, type TransformOptions, type TransformPreset, type VaporDirectiveNode, type VaporHelper, type WithDirectiveIRNode, compile, resolveDirectiveNode, resolveNode, transform, transformChildren, transformElement, transformNode, transformTemplateRef, transformText, transformVBind, transformVHtml, transformVModel, transformVOn, transformVShow, transformVSlot };