@vue-jsx-vapor/compiler/dist/index.d.ts

Vue JSX Vapor Compiler

import { Prettify } from "@vue/shared";
import { BaseCodegenResult, CodegenOptions as CodegenOptions$1, CommentNode, CompilerCompatOptions, CompilerOptions as CompilerOptions$1, CompoundExpressionNode, DirectiveNode, SimpleExpressionNode, TransformOptions as TransformOptions$1 } from "@vue/compiler-dom";
import { JSXAttribute, JSXElement, JSXFragment, Node } from "@babel/types";

//#region src/transform.d.ts
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;
  handlerModifiers?: SetEventIRNode['modifiers'];
  model?: boolean;
  modelModifiers?: string[];
}
type StructuralDirectiveTransform = (node: JSXElement, dir: JSXAttribute, context: TransformContext) => void | (() => void);
type TransformOptions = HackOptions<TransformOptions$1> & {
  source?: string;
  templates?: string[];
  /**
   * Compile JSX Component to createComponentWithFallback.
   * @default false
   */
  withFallback?: boolean;
};
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' | 'inline' | 'bindingMetadata' | 'prefixIdentifiers' | 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[], operation: OperationNode | OperationNode[], getEffectIndex?: () => number, getOperationIndex?: () => number): void;
  registerOperation(operation: OperationNode | OperationNode[], getOperationIndex?: () => number): 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;
declare function createStructuralDirectiveTransform(name: string | string[], fn: StructuralDirectiveTransform): NodeTransform;
//#endregion
//#region src/ir/component.d.ts
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;
}
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;
//#endregion
//#region src/ir/index.d.ts
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,
  INSERT_NODE = 9,
  PREPEND_NODE = 10,
  CREATE_COMPONENT_NODE = 11,
  SLOT_OUTLET_NODE = 12,
  DIRECTIVE = 13,
  DECLARE_OLD_REF = 14,
  // consider make it more general
  IF = 15,
  FOR = 16,
  GET_TEXT_CHILD = 17,
  CREATE_NODES = 18,
  SET_NODES = 19,
}
interface BaseIRNode {
  type: IRNodeTypes;
}
interface RootNode {
  type: IRNodeTypes.ROOT | JSXFragment['type'];
  source: string;
  children: JSXFragment['children'];
}
interface BlockIRNode extends BaseIRNode {
  type: IRNodeTypes.BLOCK;
  node: RootNode | Node;
  dynamic: IRDynamicInfo;
  tempId: number;
  effect: IREffect[];
  operation: OperationNode[];
  returns: number[];
}
interface RootIRNode {
  type: IRNodeTypes.ROOT;
  node: RootNode;
  source: string;
  templates: string[];
  rootTemplateIndex?: number;
  component: Set<string>;
  directive: Set<string>;
  block: BlockIRNode;
  hasTemplateRef: boolean;
}
interface IfIRNode extends BaseIRNode {
  type: IRNodeTypes.IF;
  id: number;
  condition: SimpleExpressionNode;
  positive: BlockIRNode;
  negative?: BlockIRNode | IfIRNode;
  once?: boolean;
  parent?: number;
  anchor?: number;
}
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;
  component: boolean;
  onlyChild: boolean;
  parent?: number;
  anchor?: 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[];
  generated?: boolean;
}
interface SetNodesIRNode extends BaseIRNode {
  type: IRNodeTypes.SET_NODES;
  element: number;
  values: SimpleExpressionNode[];
  generated?: boolean;
}
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 CreateNodesIRNode extends BaseIRNode {
  type: IRNodeTypes.CREATE_NODES;
  id: number;
  values?: SimpleExpressionNode[];
}
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 DirectiveIRNode extends BaseIRNode {
  type: IRNodeTypes.DIRECTIVE;
  element: number;
  dir: VaporDirectiveNode;
  name: string;
  builtin?: boolean;
  asset?: boolean;
  modelType?: 'text' | 'dynamic' | 'radio' | 'checkbox' | 'select';
}
interface CreateComponentIRNode extends BaseIRNode {
  type: IRNodeTypes.CREATE_COMPONENT_NODE;
  id: number;
  tag: string;
  props: IRProps[];
  slots: IRSlots[];
  asset: boolean;
  root: boolean;
  once: boolean;
  dynamic?: SimpleExpressionNode;
  parent?: number;
  anchor?: number;
}
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;
  parent?: number;
  anchor?: number;
}
interface GetTextChildIRNode extends BaseIRNode {
  type: IRNodeTypes.GET_TEXT_CHILD;
  parent: number;
}
type IRNode = OperationNode | RootIRNode;
type OperationNode = SetPropIRNode | SetDynamicPropsIRNode | SetTextIRNode | SetNodesIRNode | SetEventIRNode | SetDynamicEventsIRNode | SetHtmlIRNode | SetTemplateRefIRNode | CreateNodesIRNode | InsertNodeIRNode | PrependNodeIRNode | DirectiveIRNode | IfIRNode | ForIRNode | CreateComponentIRNode | DeclareOldRefIRNode | SlotOutletIRNode | GetTextChildIRNode;
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;
  hasDynamicChild?: boolean;
  operation?: OperationNode;
}
interface IREffect {
  expressions: SimpleExpressionNode[];
  operations: OperationNode[];
}
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 InsertionStateTypes = IfIRNode | ForIRNode | SlotOutletIRNode | CreateComponentIRNode;
declare function isBlockOperation(op: OperationNode): op is InsertionStateTypes;
//#endregion
//#region src/generate.d.ts
type CodegenOptions = Omit<CodegenOptions$1, 'optimizeImports' | 'inline' | 'bindingMetadata' | 'prefixIdentifiers'> & {
  templates?: string[];
};
declare class CodegenContext {
  ir: RootIRNode;
  options: Required<CodegenOptions>;
  helpers: Set<string>;
  helper: (name: string) => string;
  delegates: Set<string>;
  identifiers: Record<string, (string | SimpleExpressionNode)[]>;
  block: BlockIRNode;
  withId<T>(fn: () => T, map: Record<string, string | SimpleExpressionNode | null>): T;
  enterBlock(block: BlockIRNode): () => BlockIRNode;
  scopeLevel: number;
  enterScope(): [level: number, exit: () => number];
  constructor(ir: RootIRNode, options: CodegenOptions);
}
interface VaporCodegenResult extends Omit<BaseCodegenResult, 'preamble'> {
  ast: RootIRNode;
  helpers: Set<string>;
  templates: string[];
  delegates: Set<string>;
}
declare function generate(ir: RootIRNode, options?: CodegenOptions): VaporCodegenResult;
//#endregion
//#region src/compile.d.ts
declare function compile(source: JSXElement | JSXFragment | string, options?: CompilerOptions): VaporCodegenResult;
type CompilerOptions = HackOptions<CompilerOptions$1> & TransformOptions;
type TransformPreset = [NodeTransform[], Record<string, DirectiveTransform>];
//#endregion
//#region src/transforms/transformText.d.ts
declare const transformText: NodeTransform;
//#endregion
//#region src/transforms/transformElement.d.ts
declare const transformElement: NodeTransform;
//#endregion
//#region src/transforms/transformChildren.d.ts
declare const transformChildren: NodeTransform;
//#endregion
//#region src/transforms/transformTemplateRef.d.ts
declare const transformTemplateRef: NodeTransform;
//#endregion
//#region src/transforms/vBind.d.ts
declare const transformVBind: DirectiveTransform;
//#endregion
//#region src/transforms/vOn.d.ts
declare const transformVOn: DirectiveTransform;
//#endregion
//#region src/transforms/vSlot.d.ts
declare const transformVSlot: NodeTransform;
//#endregion
//#region src/transforms/vSlots.d.ts
declare const transformVSlots: DirectiveTransform;
//#endregion
//#region src/transforms/vModel.d.ts
declare const transformVModel: DirectiveTransform;
//#endregion
//#region src/transforms/vShow.d.ts
declare const transformVShow: DirectiveTransform;
//#endregion
//#region src/transforms/vHtml.d.ts
declare const transformVHtml: DirectiveTransform;
//#endregion
//#region src/transforms/vFor.d.ts
declare const transformVFor: NodeTransform;
//#endregion
//#region src/transforms/vIf.d.ts
declare const transformVIf: NodeTransform;
//#endregion
//#region src/transforms/vOnce.d.ts
declare const transformVOnce: NodeTransform;
//#endregion
//#region src/transforms/vText.d.ts
declare const transformVText: DirectiveTransform;
//#endregion
export { BaseIRNode, BlockIRNode, CodegenContext, CodegenOptions, CompilerOptions, CreateComponentIRNode, CreateNodesIRNode, DeclareOldRefIRNode, DirectiveIRNode, DirectiveTransform, DirectiveTransformResult, DynamicFlag, ForIRNode, GetTextChildIRNode, HackOptions, IRDynamicInfo, IRDynamicPropsKind, IREffect, IRFor, IRNode, IRNodeTypes, IRProp, IRProps, IRPropsDynamicAttribute, IRPropsDynamicExpression, IRPropsStatic, IRSlotDynamic, IRSlotDynamicBasic, IRSlotDynamicConditional, IRSlotDynamicLoop, IRSlotType, IRSlots, IRSlotsExpression, IRSlotsStatic, IfIRNode, InsertNodeIRNode, InsertionStateTypes, KeyOverride, NodeTransform, OperationNode, PrependNodeIRNode, RootIRNode, RootNode, SetDynamicEventsIRNode, SetDynamicPropsIRNode, SetEventIRNode, SetHtmlIRNode, SetNodesIRNode, SetPropIRNode, SetTemplateRefIRNode, SetTextIRNode, SlotBlockIRNode, SlotOutletIRNode, StructuralDirectiveTransform, TransformContext, TransformOptions, TransformPreset, VaporCodegenResult, VaporDirectiveNode, compile, createStructuralDirectiveTransform, generate, isBlockOperation, transform, transformChildren, transformElement, transformNode, transformTemplateRef, transformText, transformVBind, transformVFor, transformVHtml, transformVIf, transformVModel, transformVOn, transformVOnce, transformVShow, transformVSlot, transformVSlots, transformVText };