first

node_modules/vue/packages/compiler-sfc/dist/compiler-sfc.d.ts

@@ -0,0 +1,454 @@
+import { LazyResult } from 'postcss';
+import { ParserPlugin } from '@babel/parser';
+
+declare interface AssetURLOptions {
+    [name: string]: string | string[];
+}
+
+declare type ASTAttr = {
+    name: string;
+    value: any;
+    dynamic?: boolean;
+    start?: number;
+    end?: number;
+};
+
+declare type ASTDirective = {
+    name: string;
+    rawName: string;
+    value: string;
+    arg: string | null;
+    isDynamicArg: boolean;
+    modifiers: ASTModifiers | null;
+    start?: number;
+    end?: number;
+};
+
+declare type ASTElement = {
+    type: 1;
+    tag: string;
+    attrsList: Array<ASTAttr>;
+    attrsMap: {
+        [key: string]: any;
+    };
+    rawAttrsMap: {
+        [key: string]: ASTAttr;
+    };
+    parent: ASTElement | void;
+    children: Array<ASTNode>;
+    start?: number;
+    end?: number;
+    processed?: true;
+    static?: boolean;
+    staticRoot?: boolean;
+    staticInFor?: boolean;
+    staticProcessed?: boolean;
+    hasBindings?: boolean;
+    text?: string;
+    attrs?: Array<ASTAttr>;
+    dynamicAttrs?: Array<ASTAttr>;
+    props?: Array<ASTAttr>;
+    plain?: boolean;
+    pre?: true;
+    ns?: string;
+    component?: string;
+    inlineTemplate?: true;
+    transitionMode?: string | null;
+    slotName?: string | null;
+    slotTarget?: string | null;
+    slotTargetDynamic?: boolean;
+    slotScope?: string | null;
+    scopedSlots?: {
+        [name: string]: ASTElement;
+    };
+    ref?: string;
+    refInFor?: boolean;
+    if?: string;
+    ifProcessed?: boolean;
+    elseif?: string;
+    else?: true;
+    ifConditions?: ASTIfConditions;
+    for?: string;
+    forProcessed?: boolean;
+    key?: string;
+    alias?: string;
+    iterator1?: string;
+    iterator2?: string;
+    staticClass?: string;
+    classBinding?: string;
+    staticStyle?: string;
+    styleBinding?: string;
+    events?: ASTElementHandlers;
+    nativeEvents?: ASTElementHandlers;
+    transition?: string | true;
+    transitionOnAppear?: boolean;
+    model?: {
+        value: string;
+        callback: string;
+        expression: string;
+    };
+    directives?: Array<ASTDirective>;
+    forbidden?: true;
+    once?: true;
+    onceProcessed?: boolean;
+    wrapData?: (code: string) => string;
+    wrapListeners?: (code: string) => string;
+    ssrOptimizability?: number;
+};
+
+declare type ASTElementHandler = {
+    value: string;
+    params?: Array<any>;
+    modifiers: ASTModifiers | null;
+    dynamic?: boolean;
+    start?: number;
+    end?: number;
+};
+
+declare type ASTElementHandlers = {
+    [key: string]: ASTElementHandler | Array<ASTElementHandler>;
+};
+
+declare type ASTExpression = {
+    type: 2;
+    expression: string;
+    text: string;
+    tokens: Array<string | Object>;
+    static?: boolean;
+    ssrOptimizability?: number;
+    start?: number;
+    end?: number;
+};
+
+declare type ASTIfCondition = {
+    exp: string | null;
+    block: ASTElement;
+};
+
+declare type ASTIfConditions = Array<ASTIfCondition>;
+
+declare type ASTModifiers = {
+    [key: string]: boolean;
+};
+
+declare type ASTNode = ASTElement | ASTText | ASTExpression;
+
+declare type ASTText = {
+    type: 3;
+    text: string;
+    static?: boolean;
+    isComment?: boolean;
+    ssrOptimizability?: number;
+    start?: number;
+    end?: number;
+};
+
+declare type BindingMetadata = {
+    [key: string]: BindingTypes | undefined;
+} & {
+    __isScriptSetup?: boolean;
+};
+
+declare const enum BindingTypes {
+    /**
+     * returned from data()
+     */
+    DATA = "data",
+    /**
+     * declared as a prop
+     */
+    PROPS = "props",
+    /**
+     * a local alias of a `<script setup>` destructured prop.
+     * the original is stored in __propsAliases of the bindingMetadata object.
+     */
+    PROPS_ALIASED = "props-aliased",
+    /**
+     * a let binding (may or may not be a ref)
+     */
+    SETUP_LET = "setup-let",
+    /**
+     * a const binding that can never be a ref.
+     * these bindings don't need `unref()` calls when processed in inlined
+     * template expressions.
+     */
+    SETUP_CONST = "setup-const",
+    /**
+     * a const binding that does not need `unref()`, but may be mutated.
+     */
+    SETUP_REACTIVE_CONST = "setup-reactive-const",
+    /**
+     * a const binding that may be a ref.
+     */
+    SETUP_MAYBE_REF = "setup-maybe-ref",
+    /**
+     * bindings that are guaranteed to be refs
+     */
+    SETUP_REF = "setup-ref",
+    /**
+     * declared by other options, e.g. computed, inject
+     */
+    OPTIONS = "options"
+}
+
+declare type CompiledResult = {
+    ast: ASTElement | null;
+    render: string;
+    staticRenderFns: Array<string>;
+    stringRenderFns?: Array<string>;
+    errors?: Array<string | WarningMessage>;
+    tips?: Array<string | WarningMessage>;
+};
+
+export declare type CompilerOptions = {
+    warn?: Function;
+    modules?: Array<ModuleOptions>;
+    directives?: {
+        [key: string]: Function;
+    };
+    staticKeys?: string;
+    isUnaryTag?: (tag: string) => boolean | undefined;
+    canBeLeftOpenTag?: (tag: string) => boolean | undefined;
+    isReservedTag?: (tag: string) => boolean | undefined;
+    preserveWhitespace?: boolean;
+    whitespace?: 'preserve' | 'condense';
+    optimize?: boolean;
+    mustUseProp?: (tag: string, type: string | null, name: string) => boolean;
+    isPreTag?: (attr: string) => boolean | null;
+    getTagNamespace?: (tag: string) => string | undefined;
+    expectHTML?: boolean;
+    isFromDOM?: boolean;
+    shouldDecodeTags?: boolean;
+    shouldDecodeNewlines?: boolean;
+    shouldDecodeNewlinesForHref?: boolean;
+    outputSourceRange?: boolean;
+    shouldKeepComment?: boolean;
+    delimiters?: [string, string];
+    comments?: boolean;
+    scopeId?: string;
+    bindings?: BindingMetadata;
+};
+
+/**
+ * Compile `<script setup>`
+ * It requires the whole SFC descriptor because we need to handle and merge
+ * normal `<script>` + `<script setup>` if both are present.
+ */
+export declare function compileScript(sfc: SFCDescriptor, options?: SFCScriptCompileOptions): SFCScriptBlock;
+
+export declare function compileStyle(options: SFCStyleCompileOptions): SFCStyleCompileResults;
+
+export declare function compileStyleAsync(options: SFCStyleCompileOptions): Promise<SFCStyleCompileResults>;
+
+export declare function compileTemplate(options: SFCTemplateCompileOptions): SFCTemplateCompileResults;
+
+export declare function generateCodeFrame(source: string, start?: number, end?: number): string;
+
+declare interface ImportBinding {
+    isType: boolean;
+    imported: string;
+    source: string;
+    isFromSetup: boolean;
+    isUsedInTemplate: boolean;
+}
+
+declare type ModuleOptions = {
+    preTransformNode?: (el: ASTElement) => ASTElement | null | void;
+    transformNode?: (el: ASTElement) => ASTElement | null | void;
+    postTransformNode?: (el: ASTElement) => void;
+    genData?: (el: ASTElement) => string;
+    transformCode?: (el: ASTElement, code: string) => string;
+    staticKeys?: Array<string>;
+};
+
+export declare function parse(options: SFCParseOptions): SFCDescriptor;
+
+/**
+ * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
+ */
+export declare function parseComponent(source: string, options?: VueTemplateCompilerParseOptions): SFCDescriptor;
+
+declare interface RawSourceMap extends StartOfSourceMap {
+    version: string;
+    sources: string[];
+    names: string[];
+    sourcesContent?: string[];
+    mappings: string;
+}
+
+/**
+ * Utility for rewriting `export default` in a script block into a variable
+ * declaration so that we can inject things into it
+ */
+export declare function rewriteDefault(input: string, as: string, parserPlugins?: ParserPlugin[]): string;
+
+export declare interface SFCBlock extends SFCCustomBlock {
+    lang?: string;
+    scoped?: boolean;
+    module?: string | boolean;
+}
+
+export declare interface SFCCustomBlock {
+    type: string;
+    content: string;
+    attrs: {
+        [key: string]: string | true;
+    };
+    start: number;
+    end: number;
+    src?: string;
+    map?: RawSourceMap;
+}
+
+export declare interface SFCDescriptor {
+    source: string;
+    filename: string;
+    template: SFCBlock | null;
+    script: SFCScriptBlock | null;
+    scriptSetup: SFCScriptBlock | null;
+    styles: SFCBlock[];
+    customBlocks: SFCCustomBlock[];
+    cssVars: string[];
+    errors: (string | WarningMessage)[];
+    /**
+     * compare with an existing descriptor to determine whether HMR should perform
+     * a reload vs. re-render.
+     *
+     * Note: this comparison assumes the prev/next script are already identical,
+     * and only checks the special case where `<script setup lang="ts">` unused
+     * import pruning result changes due to template changes.
+     */
+    shouldForceReload: (prevImports: Record<string, ImportBinding>) => boolean;
+}
+
+export declare interface SFCParseOptions {
+    source: string;
+    filename?: string;
+    compiler?: TemplateCompiler;
+    compilerParseOptions?: VueTemplateCompilerParseOptions;
+    sourceRoot?: string;
+    sourceMap?: boolean;
+    /**
+     * @deprecated use `sourceMap` instead.
+     */
+    needMap?: boolean;
+}
+
+export declare interface SFCScriptBlock extends SFCBlock {
+    type: 'script';
+    setup?: string | boolean;
+    bindings?: BindingMetadata;
+    imports?: Record<string, ImportBinding>;
+    /**
+     * import('\@babel/types').Statement
+     */
+    scriptAst?: any[];
+    /**
+     * import('\@babel/types').Statement
+     */
+    scriptSetupAst?: any[];
+}
+
+export declare interface SFCScriptCompileOptions {
+    /**
+     * Scope ID for prefixing injected CSS variables.
+     * This must be consistent with the `id` passed to `compileStyle`.
+     */
+    id: string;
+    /**
+     * Production mode. Used to determine whether to generate hashed CSS variables
+     */
+    isProd?: boolean;
+    /**
+     * Enable/disable source map. Defaults to true.
+     */
+    sourceMap?: boolean;
+    /**
+     * https://babeljs.io/docs/en/babel-parser#plugins
+     */
+    babelParserPlugins?: ParserPlugin[];
+}
+
+export declare interface SFCStyleCompileOptions {
+    source: string;
+    filename: string;
+    id: string;
+    map?: any;
+    scoped?: boolean;
+    trim?: boolean;
+    preprocessLang?: string;
+    preprocessOptions?: any;
+    postcssOptions?: any;
+    postcssPlugins?: any[];
+    isProd?: boolean;
+}
+
+export declare interface SFCStyleCompileResults {
+    code: string;
+    map: any | void;
+    rawResult: LazyResult | void;
+    errors: string[];
+}
+
+export declare interface SFCTemplateCompileOptions {
+    source: string;
+    filename: string;
+    compiler?: TemplateCompiler;
+    compilerOptions?: CompilerOptions;
+    transformAssetUrls?: AssetURLOptions | boolean;
+    transformAssetUrlsOptions?: TransformAssetUrlsOptions;
+    preprocessLang?: string;
+    preprocessOptions?: any;
+    transpileOptions?: any;
+    isProduction?: boolean;
+    isFunctional?: boolean;
+    optimizeSSR?: boolean;
+    prettify?: boolean;
+    isTS?: boolean;
+    bindings?: BindingMetadata;
+}
+
+export declare interface SFCTemplateCompileResults {
+    ast: Object | undefined;
+    code: string;
+    source: string;
+    tips: (string | WarningMessage)[];
+    errors: (string | WarningMessage)[];
+}
+
+declare interface StartOfSourceMap {
+    file?: string;
+    sourceRoot?: string;
+}
+
+export declare interface TemplateCompiler {
+    parseComponent(source: string, options?: any): SFCDescriptor;
+    compile(template: string, options: CompilerOptions): CompiledResult;
+    ssrCompile(template: string, options: CompilerOptions): CompiledResult;
+}
+
+declare interface TransformAssetUrlsOptions {
+    /**
+     * If base is provided, instead of transforming relative asset urls into
+     * imports, they will be directly rewritten to absolute urls.
+     */
+    base?: string;
+    /**
+     * If true, also processes absolute urls.
+     */
+    includeAbsolute?: boolean;
+}
+
+declare interface VueTemplateCompilerParseOptions {
+    pad?: 'line' | 'space' | boolean;
+    deindent?: boolean;
+    outputSourceRange?: boolean;
+}
+
+export declare type WarningMessage = {
+    msg: string;
+    start?: number;
+    end?: number;
+};
+
+export { }