svelte2tsx 0.4.13 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte2tsx",
-  "version": "0.4.13",
+  "version": "0.5.2",
   "description": "Convert Svelte components to TSX for type checking",
   "author": "David Pershouse",
   "license": "MIT",
@@ -34,7 +34,7 @@
     "source-map": "^0.6.1",
     "source-map-support": "^0.5.16",
     "sourcemap-codec": "^1.4.8",
-    "svelte": "~3.44.3",
+    "svelte": "~3.46.1",
     "tiny-glob": "^0.2.6",
     "tslib": "^1.10.0",
     "typescript": "^4.5.3"

package/svelte-jsx.d.ts

@@ -1,5 +1,303 @@
 /// <reference lib="dom" />
-/* eslint @typescript-eslint/no-unused-vars: off */
+
+declare namespace svelteHTML {
+
+  // Every namespace eligible for use needs to implement the following two functions
+  function mapElementTag<K extends keyof ElementTagNameMap>(
+    tag: K
+  ): ElementTagNameMap[K];
+  function mapElementTag<K extends keyof SVGElementTagNameMap>(
+    tag: K
+  ): SVGElementTagNameMap[K];
+  function mapElementTag(
+    tag: any
+  ): HTMLElement;
+
+  function createElement<Elements extends IntrinsicElements, Key extends keyof Elements>(
+    element: Key, attrs: Elements[Key]
+  ): Key extends keyof ElementTagNameMap ? ElementTagNameMap[Key] : Key extends keyof SVGElementTagNameMap ? SVGElementTagNameMap[Key] : HTMLElement;
+
+
+  type NativeElement = HTMLElement;
+
+  // TypeScript SVGElement has no `dataset` (Chrome 55+, Firefox 51+).
+  type Element = NativeElement & {
+    dataset: DOMStringMap;
+  };
+
+  //
+  // Event Handler Types
+  // ----------------------------------------------------------------------
+  type EventHandler<E extends Event = Event, T extends EventTarget = HTMLElement> =
+    svelte.JSX.EventHandler<E,T>;
+
+  type ClipboardEventHandler<T extends EventTarget> = svelte.JSX.ClipboardEventHandler<T>;
+  type CompositionEventHandler<T extends EventTarget> = svelte.JSX.CompositionEventHandler<T>;
+  type DragEventHandler<T extends EventTarget> = svelte.JSX.DragEventHandler<T>;
+  type FocusEventHandler<T extends EventTarget> = svelte.JSX.FocusEventHandler<T>;
+  type FormEventHandler<T extends EventTarget> = svelte.JSX.FormEventHandler<T>;
+  type ChangeEventHandler<T extends EventTarget> = svelte.JSX.ChangeEventHandler<T>;
+  type KeyboardEventHandler<T extends EventTarget> = svelte.JSX.KeyboardEventHandler<T>;
+  type MouseEventHandler<T extends EventTarget> = svelte.JSX.MouseEventHandler<T>;
+  type TouchEventHandler<T extends EventTarget> = svelte.JSX.TouchEventHandler<T>;
+  type PointerEventHandler<T extends EventTarget> = svelte.JSX.PointerEventHandler<T>;
+  type UIEventHandler<T extends EventTarget> = svelte.JSX.UIEventHandler<T>;
+  type WheelEventHandler<T extends EventTarget> = svelte.JSX.WheelEventHandler<T>;
+  type AnimationEventHandler<T extends EventTarget> = svelte.JSX.AnimationEventHandler<T>;
+  type TransitionEventHandler<T extends EventTarget> = svelte.JSX.TransitionEventHandler<T>;
+  type MessageEventHandler<T extends EventTarget> = svelte.JSX.MessageEventHandler<T>;
+
+  // See CSS 3 CSS-wide keywords https://www.w3.org/TR/css3-values/#common-keywords
+  // See CSS 3 Explicit Defaulting https://www.w3.org/TR/css-cascade-3/#defaulting-keywords
+  // "all CSS properties can accept these values"
+  type CSSWideKeyword = svelte.JSX.CSSWideKeyword;
+
+  // See CSS 3 <percentage> type https://drafts.csswg.org/css-values-3/#percentages
+  type CSSPercentage = svelte.JSX.CSSPercentage;
+
+  // See CSS 3 <length> type https://drafts.csswg.org/css-values-3/#lengths
+  type CSSLength = svelte.JSX.CSSLength;
+
+  // This interface is not complete. Only properties accepting
+  // unit-less numbers are listed here (see CSSProperty.js in React)
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface DOMAttributes<T extends EventTarget> extends svelte.JSX.DOMAttributes<T> {}
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface AriaAttributes extends svelte.JSX.AriaAttributes {}
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface HTMLAttributes<T extends EventTarget> extends svelte.JSX.HTMLAttributes<T> {}
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface SVGAttributes<T extends EventTarget> extends svelte.JSX.SVGAttributes<T> {
+    'xlink:actuate'?: string | undefined;
+    'xlink:arcrole'?: string | undefined;
+    'xlink:href'?: string | undefined;
+    'xlink:role'?: string | undefined;
+    'xlink:show'?: string | undefined;
+    'xlink:title'?: string | undefined;
+    'xlink:type'?: string | undefined;
+    'xml:base'?: string | undefined;
+    'xml:lang'?: string | undefined;
+    'xml:space'?: string | undefined;
+    'xmlns'?: string | undefined;
+    'xmlns:xlink'?: string | undefined;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface HTMLProps<T extends EventTarget> extends HTMLAttributes<T> {}
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface SVGProps<T extends EventTarget> extends SVGAttributes<T> {}
+  
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface SvelteInputProps extends svelte.JSX.SvelteInputProps {}
+  
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface SvelteWindowProps extends svelte.JSX.SvelteWindowProps {}
+  
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface SapperAnchorProps extends svelte.JSX.SapperAnchorProps {}
+  
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface SvelteKitAnchorProps extends svelte.JSX.SvelteKitAnchorProps {}
+  
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface SvelteMediaTimeRange extends svelte.JSX.SvelteMediaTimeRange {}
+  
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface SvelteMediaProps extends svelte.JSX.SvelteMediaProps {}
+  
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface SvelteVideoProps extends svelte.JSX.SvelteVideoProps {}
+  
+  // no "extends svelte.JSX" because else we wouldn't get the references to the right interfaces
+  interface IntrinsicElements {
+    // HTML
+    a: HTMLProps<HTMLAnchorElement> & SapperAnchorProps & SvelteKitAnchorProps;
+    abbr: HTMLProps<HTMLElement>;
+    address: HTMLProps<HTMLElement>;
+    area: HTMLProps<HTMLAreaElement>;
+    article: HTMLProps<HTMLElement>;
+    aside: HTMLProps<HTMLElement>;
+    audio: HTMLProps<HTMLAudioElement> & SvelteMediaProps;
+    b: HTMLProps<HTMLElement>;
+    base: HTMLProps<HTMLBaseElement>;
+    bdi: HTMLProps<HTMLElement>;
+    bdo: HTMLProps<HTMLElement>;
+    big: HTMLProps<HTMLElement>;
+    blockquote: HTMLProps<HTMLElement>;
+    body: HTMLProps<HTMLBodyElement>;
+    br: HTMLProps<HTMLBRElement>;
+    button: HTMLProps<HTMLButtonElement>;
+    canvas: HTMLProps<HTMLCanvasElement>;
+    caption: HTMLProps<HTMLElement>;
+    cite: HTMLProps<HTMLElement>;
+    code: HTMLProps<HTMLElement>;
+    col: HTMLProps<HTMLTableColElement>;
+    colgroup: HTMLProps<HTMLTableColElement>;
+    data: HTMLProps<HTMLElement>;
+    datalist: HTMLProps<HTMLDataListElement>;
+    dd: HTMLProps<HTMLElement>;
+    del: HTMLProps<HTMLElement>;
+    details: HTMLProps<HTMLElement>;
+    dfn: HTMLProps<HTMLElement>;
+    dialog: HTMLProps<HTMLElement>;
+    div: HTMLProps<HTMLDivElement>;
+    dl: HTMLProps<HTMLDListElement>;
+    dt: HTMLProps<HTMLElement>;
+    em: HTMLProps<HTMLElement>;
+    embed: HTMLProps<HTMLEmbedElement>;
+    fieldset: HTMLProps<HTMLFieldSetElement>;
+    figcaption: HTMLProps<HTMLElement>;
+    figure: HTMLProps<HTMLElement>;
+    footer: HTMLProps<HTMLElement>;
+    form: HTMLProps<HTMLFormElement>;
+    h1: HTMLProps<HTMLHeadingElement>;
+    h2: HTMLProps<HTMLHeadingElement>;
+    h3: HTMLProps<HTMLHeadingElement>;
+    h4: HTMLProps<HTMLHeadingElement>;
+    h5: HTMLProps<HTMLHeadingElement>;
+    h6: HTMLProps<HTMLHeadingElement>;
+    head: HTMLProps<HTMLHeadElement>;
+    header: HTMLProps<HTMLElement>;
+    hgroup: HTMLProps<HTMLElement>;
+    hr: HTMLProps<HTMLHRElement>;
+    html: HTMLProps<HTMLHtmlElement>;
+    i: HTMLProps<HTMLElement>;
+    iframe: HTMLProps<HTMLIFrameElement>;
+    img: HTMLProps<HTMLImageElement>;
+    input: SvelteInputProps;
+    ins: HTMLProps<HTMLModElement>;
+    kbd: HTMLProps<HTMLElement>;
+    keygen: HTMLProps<HTMLElement>;
+    label: HTMLProps<HTMLLabelElement>;
+    legend: HTMLProps<HTMLLegendElement>;
+    li: HTMLProps<HTMLLIElement>;
+    link: HTMLProps<HTMLLinkElement>;
+    main: HTMLProps<HTMLElement>;
+    map: HTMLProps<HTMLMapElement>;
+    mark: HTMLProps<HTMLElement>;
+    menu: HTMLProps<HTMLElement>;
+    menuitem: HTMLProps<HTMLElement>;
+    meta: HTMLProps<HTMLMetaElement>;
+    meter: HTMLProps<HTMLElement>;
+    nav: HTMLProps<HTMLElement>;
+    noindex: HTMLProps<HTMLElement>;
+    noscript: HTMLProps<HTMLElement>;
+    object: HTMLProps<HTMLObjectElement>;
+    ol: HTMLProps<HTMLOListElement>;
+    optgroup: HTMLProps<HTMLOptGroupElement>;
+    option: HTMLProps<HTMLOptionElement>;
+    output: HTMLProps<HTMLElement>;
+    p: HTMLProps<HTMLParagraphElement>;
+    param: HTMLProps<HTMLParamElement>;
+    picture: HTMLProps<HTMLElement>;
+    pre: HTMLProps<HTMLPreElement>;
+    progress: HTMLProps<HTMLProgressElement>;
+    q: HTMLProps<HTMLQuoteElement>;
+    rp: HTMLProps<HTMLElement>;
+    rt: HTMLProps<HTMLElement>;
+    ruby: HTMLProps<HTMLElement>;
+    s: HTMLProps<HTMLElement>;
+    samp: HTMLProps<HTMLElement>;
+    script: HTMLProps<HTMLElement>;
+    section: HTMLProps<HTMLElement>;
+    select: HTMLProps<HTMLSelectElement>;
+    small: HTMLProps<HTMLElement>;
+    source: HTMLProps<HTMLSourceElement>;
+    span: HTMLProps<HTMLSpanElement>;
+    strong: HTMLProps<HTMLElement>;
+    style: HTMLProps<HTMLStyleElement>;
+    sub: HTMLProps<HTMLElement>;
+    summary: HTMLProps<HTMLElement>;
+    sup: HTMLProps<HTMLElement>;
+    table: HTMLProps<HTMLTableElement>;
+    tbody: HTMLProps<HTMLTableSectionElement>;
+    td: HTMLProps<HTMLTableDataCellElement>;
+    textarea: HTMLProps<HTMLTextAreaElement>;
+    tfoot: HTMLProps<HTMLTableSectionElement>;
+    th: HTMLProps<HTMLTableHeaderCellElement>;
+    thead: HTMLProps<HTMLTableSectionElement>;
+    time: HTMLProps<HTMLElement>;
+    title: HTMLProps<HTMLTitleElement>;
+    tr: HTMLProps<HTMLTableRowElement>;
+    track: HTMLProps<HTMLTrackElement>;
+    u: HTMLProps<HTMLElement>;
+    ul: HTMLProps<HTMLUListElement>;
+    var: HTMLProps<HTMLElement>;
+    video: HTMLProps<HTMLVideoElement> & SvelteVideoProps;
+    wbr: HTMLProps<HTMLElement>;
+
+    svg: SVGProps<SVGSVGElement>;
+
+    animate: SVGProps<SVGElement>; // @TODO: It is SVGAnimateElement but not in dom.d.ts for now.
+    circle: SVGProps<SVGCircleElement>;
+    clipPath: SVGProps<SVGClipPathElement>;
+    defs: SVGProps<SVGDefsElement>;
+    desc: SVGProps<SVGDescElement>;
+    ellipse: SVGProps<SVGEllipseElement>;
+    feBlend: SVGProps<SVGFEBlendElement>;
+    feColorMatrix: SVGProps<SVGFEColorMatrixElement>;
+    feComponentTransfer: SVGProps<SVGFEComponentTransferElement>;
+    feComposite: SVGProps<SVGFECompositeElement>;
+    feConvolveMatrix: SVGProps<SVGFEConvolveMatrixElement>;
+    feDiffuseLighting: SVGProps<SVGFEDiffuseLightingElement>;
+    feDisplacementMap: SVGProps<SVGFEDisplacementMapElement>;
+    feDistantLight: SVGProps<SVGFEDistantLightElement>;
+    feFlood: SVGProps<SVGFEFloodElement>;
+    feFuncA: SVGProps<SVGFEFuncAElement>;
+    feFuncB: SVGProps<SVGFEFuncBElement>;
+    feFuncG: SVGProps<SVGFEFuncGElement>;
+    feFuncR: SVGProps<SVGFEFuncRElement>;
+    feGaussianBlur: SVGProps<SVGFEGaussianBlurElement>;
+    feImage: SVGProps<SVGFEImageElement>;
+    feMerge: SVGProps<SVGFEMergeElement>;
+    feMergeNode: SVGProps<SVGFEMergeNodeElement>;
+    feMorphology: SVGProps<SVGFEMorphologyElement>;
+    feOffset: SVGProps<SVGFEOffsetElement>;
+    fePointLight: SVGProps<SVGFEPointLightElement>;
+    feSpecularLighting: SVGProps<SVGFESpecularLightingElement>;
+    feSpotLight: SVGProps<SVGFESpotLightElement>;
+    feTile: SVGProps<SVGFETileElement>;
+    feTurbulence: SVGProps<SVGFETurbulenceElement>;
+    filter: SVGProps<SVGFilterElement>;
+    foreignObject: SVGProps<SVGForeignObjectElement>;
+    g: SVGProps<SVGGElement>;
+    image: SVGProps<SVGImageElement>;
+    line: SVGProps<SVGLineElement>;
+    linearGradient: SVGProps<SVGLinearGradientElement>;
+    marker: SVGProps<SVGMarkerElement>;
+    mask: SVGProps<SVGMaskElement>;
+    metadata: SVGProps<SVGMetadataElement>;
+    path: SVGProps<SVGPathElement>;
+    pattern: SVGProps<SVGPatternElement>;
+    polygon: SVGProps<SVGPolygonElement>;
+    polyline: SVGProps<SVGPolylineElement>;
+    radialGradient: SVGProps<SVGRadialGradientElement>;
+    rect: SVGProps<SVGRectElement>;
+    stop: SVGProps<SVGStopElement>;
+    switch: SVGProps<SVGSwitchElement>;
+    symbol: SVGProps<SVGSymbolElement>;
+    text: SVGProps<SVGTextElement>;
+    textPath: SVGProps<SVGTextPathElement>;
+    tspan: SVGProps<SVGTSpanElement>;
+    use: SVGProps<SVGUseElement>;
+    view: SVGProps<SVGViewElement>;
+
+    // Svelte specific
+    sveltewindow: HTMLProps<Window> & SvelteWindowProps;
+    sveltebody: HTMLProps<HTMLElement>;
+    sveltefragment: { slot?: string; };
+    svelteoptions: { [name: string]: any };
+    sveltehead: { [name: string]: any };
+
+    [name: string]: { [name: string]: any };
+  }
+}
+
 /**
  * Adapted from jsx-dom
  * @see https://github.com/proteriax/jsx-dom/blob/be06937ba16908d87bf8aa4372a3583133e02b8a/index.d.ts
@@ -555,6 +853,7 @@ declare namespace svelte.JSX {
       tabindex?: number | undefined | null;
       target?: string | undefined | null;
       title?: string | undefined | null;
+      translate?: "yes" | "no" | "" | undefined | null;
       type?: string | undefined | null;
       usemap?: string | undefined | null;
       value?: any | undefined | null;
@@ -1146,6 +1445,8 @@ declare namespace svelte.JSX {
       sveltewindow: HTMLProps<Window> & SvelteWindowProps;
       sveltebody: HTMLProps<HTMLElement>;
       sveltefragment: { slot?: string; };
+      svelteoptions: { [name: string]: any };
+      sveltehead: { [name: string]: any };
 
       [name: string]: { [name: string]: any };
     }

package/svelte-native-jsx.d.ts

@@ -1,6 +1,16 @@
 /* eslint @typescript-eslint/no-unused-vars: off */
 declare namespace svelteNative.JSX {
 
+    // Every namespace eligible for use needs to implement the following two functions
+    function mapElementTag(
+        tag: string
+    ): any;
+
+    function createElement<Elements extends IntrinsicElements, Key extends keyof Elements>(
+        element: Key, attrs: Elements[Key]
+    ): any;
+
+
     /* svelte specific */
     interface ElementClass {
         $$prop_def: any;

package/svelte-shims.d.ts

@@ -120,6 +120,7 @@ declare function __sveltets_1_ensureAction(actionCall: SvelteActionReturnType):
 declare function __sveltets_1_ensureTransition(transitionCall: SvelteTransitionReturnType): {};
 declare function __sveltets_1_ensureFunction(expression: (e: Event & { detail?: any }) => unknown ): {};
 declare function __sveltets_1_ensureType<T>(type: AConstructorTypeOf<T>, el: T): {};
+declare function __sveltets_1_ensureType<T1, T2>(type1: AConstructorTypeOf<T1>, type2: AConstructorTypeOf<T2>, el: T1 | T2): {};
 declare function __sveltets_1_createEnsureSlot<Slots = Record<string, Record<string, any>>>(): <K1 extends keyof Slots, K2 extends keyof Slots[K1]>(k1: K1, k2: K2, val: Slots[K1][K2]) => Slots[K1][K2];
 declare function __sveltets_1_ensureRightProps<Props>(props: Props): {};
 declare function __sveltets_1_cssProp(prop: Record<string, any>): {};
@@ -216,3 +217,45 @@ declare function __sveltets_1_createSvelte2TsxComponent<Props, Events, Slots>(
 
 declare function __sveltets_1_unwrapArr<T>(arr: ArrayLike<T>): T
 declare function __sveltets_1_unwrapPromiseLike<T>(promise: PromiseLike<T> | T): T
+
+// v2
+declare function __sveltets_2_createCreateSlot<Slots = Record<string, Record<string, any>>>(): <SlotName extends keyof Slots>(slotName: SlotName, attrs: Slots[SlotName]) => Record<string, any>;
+declare function __sveltets_2_createComponentAny(props: Record<string, any>): Svelte2TsxComponent<any, any, any>;
+
+declare function __sveltets_2_any(...dummy: any[]): any;
+declare function __sveltets_2_empty(...dummy: any[]): {};
+
+declare function __sveltets_2_cssProp(prop: Record<string, any>): {};
+
+type __sveltets_2_SvelteAnimationReturnType = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+declare var __sveltets_2_AnimationMove: { from: DOMRect, to: DOMRect }
+declare function __sveltets_2_ensureAnimation(animationCall: __sveltets_2_SvelteAnimationReturnType): {};
+
+type __sveltets_2_SvelteActionReturnType = {
+	update?: (args: any) => void,
+	destroy?: () => void
+} | void
+declare function __sveltets_2_ensureAction(actionCall: __sveltets_2_SvelteActionReturnType): {};
+
+type __sveltets_2_SvelteTransitionConfig = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+type __sveltets_2_SvelteTransitionReturnType = __sveltets_2_SvelteTransitionConfig | (() => __sveltets_2_SvelteTransitionConfig)
+declare function __sveltets_2_ensureTransition(transitionCall: __sveltets_2_SvelteTransitionReturnType): {};
+
+declare function __sveltets_2_ensureType<T>(type: AConstructorTypeOf<T>, el: T): {};
+declare function __sveltets_2_ensureType<T1, T2>(type1: AConstructorTypeOf<T1>, type2: AConstructorTypeOf<T2>, el: T1 | T2): {};
+
+declare function __sveltets_2_ensureComponent<T extends new (args: {target: any, props?: any}) => Svelte2TsxComponent<any, any, any>>(type: T): T extends never ? Svelte2TsxComponent<any, any, any> : T;
+
+declare function __sveltets_2_ensureArray<T extends ArrayLike<unknown>>(array: T): T extends ArrayLike<infer U> ? U[] : any[];