@marko/ts-plugin 0.0.0 → 3.1.0

package/dist/marko.internal.d.ts

@@ -0,0 +1,730 @@
+// This is a typescript file which defines utilities used in the output of the typescript extractor.
+declare global {
+  namespace Marko {
+    export interface Directives {}
+
+    // Extend the Body type to keep track of what is yielded (used for scope hoisted types).
+    export interface Body<
+      in Params extends readonly any[] = [],
+      out Return = void,
+    > {
+      (...params: Params): MarkoReturn<Return>;
+    }
+
+    /**
+     * Do not use or you will be fired.
+     */
+    namespace _ {
+      export const voidReturn = new (class Void {
+        readonly [Marko._.scope] = Marko._.never;
+        declare return: void;
+      })();
+      export const scope: unique symbol;
+      export const never: never;
+      export const any: any;
+
+      export function getGlobal<Override>(
+        override: Override,
+      ): [0] extends [1 & Override] ? Marko.Global : Override;
+
+      export function returned<T>(
+        rendered: () => T,
+      ): T extends { return: { value: infer Returned } } ? Returned : never;
+
+      export function hoist<T>(
+        value: () => T,
+      ): T extends () => infer R ? T & Iterable<R> : never;
+      // TODO: hoist should really be the below implementation which accounts for hoisting from unknown
+      // sections causing the getter to return undefined. Right now the type says it always has a value.
+      // export function hoist<T, U = T>(
+      //   value: () => T,
+      // ): T extends () => infer R
+      //   ? (T | (U extends undefined ? () => undefined : never)) & Iterable<R>
+      //   : never;
+
+      export function attrTagNames<Tag>(
+        tag: Tag,
+        fn: (input: AttrTagNames<InputFor<Tag>>) => void,
+      ): void;
+      export function nestedAttrTagNames<Input>(
+        input: Input,
+        fn: (input: AttrTagNames<Input>) => void,
+      ): void;
+
+      export const content: DefaultBodyContentKey;
+
+      export function el<Name extends string>(
+        name: Name,
+      ): Marko.NativeTags[Name]["return"]["value"];
+
+      export function contentFor<Name>(tag: Name): ContentFor<Name>;
+
+      export const Template: new <Overrides = unknown>() => {
+        [K in Exclude<
+          keyof Marko.Template,
+          keyof Overrides
+        >]: Marko.Template[K];
+      } & Overrides;
+
+      export function noop(value: any): void;
+
+      export function tuple<T extends readonly any[]>(...v: T): T;
+
+      export function interpolated(
+        strs: TemplateStringsArray,
+        ...exprs: (string | number | void | null | false)[]
+      ): string;
+
+      export function state<Component>(
+        component: Component,
+      ): Component extends {
+        state: infer State extends object;
+      }
+        ? State
+        : never;
+
+      export type ReturnWithScope<Input, Return> = ReturnAndScope<
+        Scopes<Input>,
+        Return
+      >;
+
+      export function instance<Constructor>(
+        constructor: Constructor,
+      ): Constructor extends abstract new (...args: any) => infer Instance
+        ? Instance
+        : never;
+
+      export function readScopes<Rendered>(rendered: Rendered): MergeScopes<
+        {
+          [K in keyof Rendered]: Rendered[K] extends infer Value
+            ? undefined extends Value
+              ? Value extends { scope: infer Scope }
+                ? [0] extends [1 & Scope]
+                  ? never
+                  : Partial<Scope>
+                : never
+              : Value extends { scope: infer Scope }
+                ? [0] extends [1 & Scope]
+                  ? never
+                  : Scope
+                : never
+            : never;
+        }[keyof Rendered]
+      >;
+
+      export function readScope<Value>(
+        value: Value,
+      ): MergeScopes<
+        undefined extends Value
+          ? Value extends { scope: infer Scope }
+            ? [0] extends [1 & Scope]
+              ? never
+              : Partial<Scope>
+            : never
+          : Value extends { scope: infer Scope }
+            ? [0] extends [1 & Scope]
+              ? never
+              : Scope
+            : never
+      >;
+
+      export function change<const Item extends readonly unknown[]>(
+        ...item: Item
+      ): UnionToIntersection<
+        Item extends
+          | readonly [infer LocalName extends string, infer Data]
+          | readonly [
+              infer LocalName extends string,
+              infer SourceName,
+              infer Data,
+            ]
+          ? Data extends {
+              [K in `${SourceName extends string
+                ? SourceName
+                : LocalName}Change`]: (value: infer V, ...args: any[]) => any;
+            }
+            ? { [K in LocalName]: V }
+            : { readonly [K in LocalName]: unknown }
+          : never
+      >;
+
+      export function bind<
+        Owner extends Marko.Component,
+        OwnerHandlers extends ComponentEventHandlers<Owner>,
+        Handler extends
+          | keyof OwnerHandlers
+          | ((...args: any) => any)
+          | false
+          | void,
+        Args extends readonly any[],
+      >(
+        owner: Owner,
+        handler: Handler,
+        ...args: Args
+      ): Args extends readonly []
+        ? Handler extends keyof OwnerHandlers
+          ? OwnerHandlers[Handler]
+          : Handler
+        : (...args: any) => any; // If typescript ever actually supports partial application maybe we do this.
+
+      export function renderTemplate<Name>(
+        template: Name,
+      ): TemplateRenderer<Name>;
+      export function renderNativeTag<Name extends string>(
+        tag: Name,
+      ): NativeTagRenderer<Name>;
+      export const missingTag: DefaultRenderer;
+      export function resolveTemplate<Template>(
+        imported: Promise<{ default: Template }>,
+      ): Template;
+      export function fallbackTemplate<Tag, Template>(
+        tag: Tag,
+        fallback: Promise<{ default: Template }>,
+      ): [0] extends [1 & Tag] ? Template : Tag;
+      export function input<Name>(tag: Name): InputFor<Name>;
+      export function inputForAttr<
+        Name,
+        Path extends readonly [string, ...string[]],
+      >(tag: Name, ...path: Path): AttrTagValue<InputFor<Name>, Path>;
+      export function renderDynamicTag<Name>(tag: Name): DynamicRenderer<Name>;
+
+      export function returnTag<
+        Input extends {
+          value: unknown;
+          valueChange?: ((value: any) => void) | false | null;
+        },
+      >(input: Input): Input;
+
+      export function forOfTag<
+        Value,
+        Item extends [0] extends [1 & Value]
+          ? any
+          : Value extends Iterable<infer Item>
+            ? Item
+            : never,
+        BodyContent extends Marko.Body<
+          [item: Item, index: number, all: Exclude<Value, false | void | null>],
+          void
+        >,
+      >(
+        input: {
+          of: Value & (Iterable<unknown> | false | void | null);
+          by?: ((item: Item, index: number) => string) | string;
+        },
+        content: BodyContent,
+      ): ReturnAndScope<BodyContentScope<BodyContent>, void>;
+
+      export function forInTag<
+        Value,
+        BodyContent extends Marko.Body<
+          [key: keyof Value, value: Value[keyof Value]],
+          void
+        >,
+      >(
+        input: {
+          in: Value | false | void | null;
+          by?: (value: Value[keyof Value], key: keyof Value) => string;
+        },
+        content: BodyContent,
+      ): ReturnAndScope<BodyContentScope<BodyContent>, void>;
+
+      export function forToTag<
+        To extends number,
+        From extends void | number,
+        Step extends void | number,
+        BodyContent extends Marko.Body<[index: number], void>,
+      >(
+        input: {
+          to: To;
+          from?: From;
+          step?: Step;
+          by?: (index: number) => string;
+        },
+        content: BodyContent,
+      ): ReturnAndScope<BodyContentScope<BodyContent>, void>;
+
+      export function forUntilTag<
+        Until extends number,
+        From extends void | number,
+        Step extends void | number,
+        BodyContent extends Marko.Body<[index: number], void>,
+      >(
+        input: {
+          until: Until;
+          from?: From;
+          step?: Step;
+          by?: (index: number) => string;
+        },
+        content: BodyContent,
+      ): ReturnAndScope<BodyContentScope<BodyContent>, void>;
+
+      export function forTag<BodyContent extends AnyMarkoBody>(
+        input: (
+          | {
+              to: number;
+              from?: number;
+              step?: number;
+            }
+          | {
+              until: number;
+              from?: number;
+              step?: number;
+            }
+          | {
+              in: any;
+            }
+          | {
+              of: any;
+            }
+        ) & { by?: string | ((...args: unknown[]) => string) },
+        content: BodyContent,
+      ): ReturnAndScope<BodyContentScope<BodyContent>, void>;
+
+      export function forOfAttrTag<
+        Value,
+        Item extends [0] extends [1 & Value]
+          ? any
+          : Value extends readonly (infer Item)[] | Iterable<infer Item>
+            ? Item
+            : never,
+        const Return extends Partial<Constraint>,
+        Constraint = unknown,
+      >(
+        input: {
+          of: Value & (Iterable<unknown> | false | void | null);
+        },
+        content: (
+          value: Item,
+          index: number,
+          all: Exclude<Value, false | void | null>,
+        ) => Return,
+        constraint?: Constraint,
+      ): {
+        [Key in keyof Return]: Return[Key] extends
+          | readonly (infer Item)[]
+          | (infer Item extends Record<PropertyKey, any>)
+          ? AttrTagByListSize<Exclude<Value, false | void | null>, Item>
+          : never;
+      };
+
+      export function forInAttrTag<
+        Value extends object,
+        const Return extends Partial<Constraint>,
+        Constraint = unknown,
+      >(
+        input: {
+          in: Value | false | void | null;
+        },
+        content: (key: keyof Value, value: Value[keyof Value]) => Return,
+        constraint?: Constraint,
+      ): {
+        [Key in keyof Return]: Return[Key] extends
+          | readonly (infer Item)[]
+          | (infer Item extends Record<PropertyKey, any>)
+          ? AttrTagByObjectSize<Value, Item>
+          : never;
+      };
+
+      export function forToAttrTag<
+        To extends number,
+        From extends void | number,
+        Step extends void | number,
+        const Return extends Partial<Constraint>,
+        Constraint = unknown,
+      >(
+        input: {
+          to: To;
+          from?: From;
+          step?: Step;
+        },
+        content: (index: number) => Return,
+        constraint?: Constraint,
+      ): {
+        [Key in keyof Return]: Return[Key] extends
+          | readonly (infer Item)[]
+          | (infer Item extends Record<PropertyKey, any>)
+          ? number extends From | To | Step
+            ? undefined | Marko.AttrTag<Item>
+            : Step extends 0
+              ? never
+              : [To] extends [From extends void ? 0 : From]
+                ? undefined
+                : Marko.AttrTag<Item>
+          : never;
+      };
+
+      export function forUntilAttrTag<
+        Until extends number,
+        From extends void | number,
+        Step extends void | number,
+        const Return extends Partial<Constraint>,
+        Constraint = unknown,
+      >(
+        input: {
+          until: Until;
+          from?: From;
+          step?: Step;
+        },
+        content: (index: number) => Return,
+        constraint?: Constraint,
+      ): {
+        [Key in keyof Return]: Return[Key] extends
+          | readonly (infer Item)[]
+          | (infer Item extends Record<PropertyKey, any>)
+          ? number extends From | Until | Step
+            ? undefined | Marko.AttrTag<Item>
+            : Step extends 0
+              ? never
+              : [Until] extends [From extends void ? 0 : From]
+                ? undefined
+                : Marko.AttrTag<Item>
+          : never;
+      };
+
+      export function forAttrTag<
+        const Return extends Partial<Constraint>,
+        Constraint = unknown,
+      >(
+        input:
+          | {
+              of: Iterable<unknown> | false | void | null;
+            }
+          | {
+              in: object | false | void | null;
+            }
+          | {
+              to: number;
+              from?: number;
+              step?: number;
+            }
+          | {
+              until: number;
+              from?: number;
+              step?: number;
+            },
+        content: (...args: unknown[]) => Return,
+        constraint?: Constraint,
+      ): {
+        [Key in keyof Return]: Return[Key] extends
+          | readonly (infer Item)[]
+          | (infer Item extends Record<PropertyKey, any>)
+          ? undefined | Marko.AttrTag<Item>
+          : never;
+      };
+
+      export function mergeAttrTags<Attrs extends readonly any[]>(
+        ...attrs: Attrs
+      ): MergeAttrTags<Attrs>;
+      export function attrTag<
+        Name extends string,
+        AttrTags extends readonly { [K in Name]: unknown }[],
+      >(name: Name, ...attrTags: AttrTags): AttrTagsToAttrTag<Name, AttrTags>;
+      export function attrTagFor<Tag, Path extends readonly string[]>(
+        tag: Tag,
+        ...path: Path
+      ): <
+        Name extends string,
+        const AttrTags extends readonly ([0] extends [1 & Tag]
+          ? Record<Name, Marko.AttrTag<unknown>>
+          : Record<
+              Name,
+              Tag extends InputFor<infer Input>
+                ? [0] extends [1 & Input]
+                  ? Marko.AttrTag<unknown>
+                  : AttrTagValue<Input, Path>
+                : Marko.AttrTag<unknown>
+            >)[],
+      >(
+        name: Name,
+        ...attrTags: AttrTags
+      ) => AttrTagsToAttrTag<Name, AttrTags>;
+
+      export type DynamicRenderer<Name> = [0] extends [1 & Name]
+        ? DefaultRenderer
+        : [Name] extends [Marko.Template<any, any> | string]
+          ? {
+              (): () => <Input extends Marko.Input<Name>>(
+                input: Marko.Directives & Input,
+              ) => ReturnAndScope<Scopes<Input>, Marko.Return<Name>>;
+            }
+          : [Name] extends [AnyMarkoBody]
+            ? BodyRenderer<Name>
+            : [Name] extends [
+                  {
+                    [BodyContentKey in DefaultBodyContentKey]?: infer BodyValue extends
+                      AnyMarkoBody;
+                  },
+                ]
+              ? BodyRenderer<BodyValue>
+              : DefaultRenderer;
+
+      export type TemplateRenderer<Template> = Template extends {
+        _: infer Renderer;
+      }
+        ? Renderer
+        : Template extends Marko.Template<infer Input, infer Return>
+          ? BaseRenderer<Input, Return>
+          : DefaultRenderer;
+
+      export interface NativeTagRenderer<Name extends string> {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
+        (): () => <__marko_internal_input extends unknown>(
+          input: Marko.Directives &
+            Marko.NativeTags[Name]["input"] &
+            Relate<
+              __marko_internal_input,
+              Marko.Directives & Marko.NativeTags[Name]["input"]
+            >,
+        ) => ReturnAndScope<
+          Scopes<__marko_internal_input>,
+          Marko.NativeTags[Name]["return"]
+        >;
+      }
+
+      export interface BodyRenderer<Body extends AnyMarkoBody> {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
+        (): () => <__marko_internal_input extends unknown>(
+          ...args: BodyParamsWithDefault<Body> &
+            Relate<__marko_internal_input, BodyParamsWithDefault<Body>>
+        ) => ReturnAndScope<
+          Scopes<__marko_internal_input extends [infer Input] ? Input : never>,
+          Body extends Marko.Body<any, infer Return> ? Return : never
+        >;
+      }
+
+      export interface BaseRenderer<Input, Return = void> {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
+        (): () => <__marko_input_with_scope extends unknown>(
+          input: Marko.Directives &
+            Input &
+            Relate<__marko_input_with_scope, Marko.Directives & Input>,
+        ) => ReturnAndScope<Scopes<__marko_input_with_scope>, Return>;
+      }
+
+      export interface DefaultRenderer {
+        (): () => <Input>(input: Input) => ReturnAndScope<Scopes<Input>, void>;
+      }
+
+      export type ResolveComponent<Component> = CheckNever<
+        ComponentOf<
+          InstanceOf<
+            Component extends { default: infer Component }
+              ? Component
+              : Component
+          >
+        >,
+        Marko.Component
+      >;
+
+      export type Relate<A, B> = B extends A ? A : B;
+    }
+  }
+}
+
+declare abstract class MarkoReturn<Return> {
+  return: Return;
+}
+
+type AnyMarkoBody = Marko.Body<any, any>;
+
+type BodyContentScope<BodyContent> = BodyContent extends (...params: any) => {
+  [Marko._.scope]: infer Scope;
+}
+  ? Scope
+  : never;
+
+type ReturnAndScope<Scope, Return> = {
+  return: Return;
+  scope: Scope;
+};
+
+type BodyParamsWithDefault<Body extends AnyMarkoBody> =
+  Body extends Marko.Body<infer Params, any>
+    ? Params extends []
+      ? [input?: Record<string, never>]
+      : Params
+    : never;
+
+type ComponentEventHandlers<Component extends Marko.Component> = {
+  [K in Exclude<
+    keyof Component,
+    Exclude<
+      keyof Marko.Component,
+      "emit" | "setState" | "setStateDirty" | "forceUpdate"
+    >
+  >]: Component[K] extends (...args: any) => any ? Component[K] : never;
+};
+
+type Scopes<Input> = [0] extends [1 & Input]
+  ? never
+  :
+      | (Input[("content" | "renderBody") & keyof Input] extends infer Prop
+          ? Prop extends (...args: any[]) => { [Marko._.scope]: infer Scope }
+            ? Scope
+            : never
+          : never)
+      | (Input[string & keyof Input] extends infer Prop
+          ? Prop extends { [Symbol.iterator]: any }
+            ? Prop extends readonly any[]
+              ? never
+              : Scopes<Prop>
+            : never
+          : never);
+
+type MergeScopes<Scopes> = {
+  [K in Scopes extends Scopes ? keyof Scopes : never]: Scopes extends Scopes
+    ? Scopes[K & keyof Scopes]
+    : never;
+};
+
+type MergeAttrTags<Attrs extends readonly any[]> = Attrs extends readonly [
+  infer A,
+  infer B,
+  ...infer Rest,
+]
+  ? MergeAttrTags<[MergeAttrTag<A, B>, ...Rest]>
+  : Attrs extends readonly [infer A]
+    ? A
+    : never;
+
+type MergeAttrTag<A, B> = {
+  [K in keyof A | keyof B]: K extends keyof A
+    ? K extends keyof B
+      ? MergeAttrTagValue<A[K], B[K]>
+      : A[K]
+    : K extends keyof B
+      ? B[K]
+      : never;
+};
+
+type MergeAttrTagValue<A, B> = A extends readonly (infer AType)[]
+  ? B extends readonly (infer BType)[]
+    ? AType | BType
+    : B extends void
+      ? A
+      : AType | B
+  : A extends void
+    ? B
+    : B extends void
+      ? A
+      : A | B;
+
+type AttrTagsToAttrTag<
+  Name extends string,
+  AttrTags extends readonly unknown[],
+> = AttrTags[number] extends infer AttrTag
+  ? AttrTag extends { [K in Name]: Marko.AttrTag<infer Input> }
+    ? [0] extends [1 & Input]
+      ? never
+      : Marko.AttrTag<Input>
+    : never
+  : never;
+
+type AttrTagByListSize<T, Item> = T extends
+  | readonly [any, ...any[]]
+  | readonly [...any[], any]
+  ? Marko.AttrTag<Item>
+  : T extends readonly []
+    ? undefined
+    : undefined | Marko.AttrTag<Item>;
+
+type AttrTagByObjectSize<
+  Value,
+  Item,
+  Keys = RecordKeys<Value>,
+  KnownKeys = KnownRecordKeys<Value>,
+> = CheckNever<
+  Keys,
+  undefined,
+  CheckNever<KnownKeys, Marko.AttrTag<Item>, undefined | Marko.AttrTag<Item>>
+>;
+
+type AttrTagValue<Input, Path extends readonly string[]> = Path extends [
+  infer Prop extends keyof Input,
+  ...infer Rest extends readonly string[],
+]
+  ? Input[Prop] & Marko.AttrTag<unknown> extends infer Value
+    ? Rest extends readonly []
+      ? Value
+      : AttrTagValue<Value, Rest>
+    : Marko.AttrTag<unknown>
+  : Marko.AttrTag<unknown>;
+
+type AttrTagNames<Input> = Record<string, never> &
+  (Input extends infer Input extends {}
+    ? {
+        [Key in keyof Input & string as `@${Input[Key] extends infer Value
+          ? Value extends Marko.AttrTag<any>
+            ? Key
+            : never
+          : never}`]: Input[Key];
+      }
+    : never);
+
+type RecordKeys<T> = keyof {
+  [K in keyof T as CheckNever<T[K], never, K>]: 0;
+};
+
+type KnownRecordKeys<T> = keyof {
+  [Key in keyof T as string extends Key
+    ? never
+    : number extends Key
+      ? never
+      : symbol extends Key
+        ? never
+        : CheckNever<T[Key], never, Key>]: 0;
+};
+
+type CheckNever<T, If, Else = T> = [T] extends [never] ? If : Else;
+type ComponentOf<T> = T extends Marko.Component ? T : T & Marko.Component;
+type InstanceOf<T> = T extends abstract new () => infer R ? R : T;
+
+type UnionToIntersection<T> = (T extends any ? (_: T) => any : never) extends (
+  _: infer U,
+) => any
+  ? U
+  : never;
+
+type DefaultBodyContentKey = keyof Exclude<
+  Marko.Renderable,
+  Marko.Template<any, any> | Marko.Body<any, any> | string
+>;
+
+type ContentFor<Name> = [0] extends [1 & Name]
+  ? DefaultBodyContentKey
+  : Name extends { api: infer API }
+    ? API extends "tags"
+      ? "content"
+      : API extends "class"
+        ? "renderBody"
+        : DefaultBodyContentKey
+    : DefaultBodyContentKey;
+
+type InputFor<Name> = 0 extends 1 & Name
+  ? any
+  : Name extends string
+    ? Name extends keyof Marko.NativeTags
+      ? Marko.NativeTags[Name]["input"]
+      : Record<string, unknown>
+    : Name extends
+          | Marko.Template<infer Input, any>
+          | { _(): () => (input: infer Input) => any }
+      ? Input
+      : Name extends
+            | Marko.Body<infer Args, any>
+            | Record<
+                DefaultBodyContentKey,
+                undefined | null | false | Marko.Body<infer Args, any>
+              >
+        ? Args extends {
+            length: infer Length;
+          }
+          ? number extends Length
+            ? Args[0] | undefined
+            : 0 extends Length
+              ? undefined
+              : Args[0]
+          : never
+        : never;
+
+export {};