mirror of
https://github.com/flarum/framework.git
synced 2024-11-28 03:32:49 +08:00
chore: rebuild dist types
This commit is contained in:
Alexander Skvortsov
parent
bdf9ddf33a
commit
82b9b7e866
517
js/dist-typings/@types/mithril/index.d.ts
vendored
Normal file
517
js/dist-typings/@types/mithril/index.d.ts
vendored
Normal file
|
|
@ -0,0 +1,517 @@
|
|||
// Type definitions for Mithril 2.0
|
||||
// Project: https://mithril.js.org/, https://github.com/mithriljs/mithril.js
|
||||
// Definitions by: Mike Linkovich <https://github.com/spacejack>, András Parditka <https://github.com/andraaspar>, Isiah Meadows <https://github.com/isiahmeadows>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
// TypeScript Version: 3.2
|
||||
/** Renders a vnode structure into a DOM element. */
|
||||
declare function render(el: Element, vnodes: Mithril.Children): void;
|
||||
|
||||
/** Mounts a component to a DOM element, enabling it to autoredraw on user events. */
|
||||
declare function mount(element: Element, component: Mithril.ComponentTypes<any, any>): void;
|
||||
/** Unmounts a component from a DOM element. */
|
||||
declare function mount(element: Element, component: null): void; // tslint:disable-line unified-signatures
|
||||
|
||||
/** Makes an XHR request and returns a promise. */
|
||||
declare function request<T>(options: Mithril.RequestOptions<T> & { url: string }): Promise<T>;
|
||||
/** Makes an XHR request and returns a promise. */
|
||||
declare function request<T>(url: string, options?: Mithril.RequestOptions<T>): Promise<T>;
|
||||
|
||||
/** Makes a JSON-P request and returns a promise. */
|
||||
declare function jsonp<T>(options: Mithril.JsonpOptions & { url: string }): Promise<T>; // tslint:disable-line:no-unnecessary-generics
|
||||
/** Makes a JSON-P request and returns a promise. */
|
||||
declare function jsonp<T>(url: string, options?: Mithril.JsonpOptions): Promise<T>; // tslint:disable-line:no-unnecessary-generics
|
||||
|
||||
declare namespace Mithril {
|
||||
interface CommonAttributes<Attrs, State> {
|
||||
/** The oninit hook is called before a vnode is touched by the virtual DOM engine. */
|
||||
oninit?(this: State, vnode: Vnode<Attrs, State>): any;
|
||||
/** The oncreate hook is called after a DOM element is created and attached to the document. */
|
||||
oncreate?(this: State, vnode: VnodeDOM<Attrs, State>): any;
|
||||
/** The onbeforeremove hook is called before a DOM element is detached from the document. If a Promise is returned, Mithril only detaches the DOM element after the promise completes. */
|
||||
onbeforeremove?(this: State, vnode: VnodeDOM<Attrs, State>): Promise<any> | void;
|
||||
/** The onremove hook is called before a DOM element is removed from the document. */
|
||||
onremove?(this: State, vnode: VnodeDOM<Attrs, State>): any;
|
||||
/** The onbeforeupdate hook is called before a vnode is diffed in a update. */
|
||||
onbeforeupdate?(this: State, vnode: Vnode<Attrs, State>, old: VnodeDOM<Attrs, State>): boolean | void;
|
||||
/** The onupdate hook is called after a DOM element is updated, while attached to the document. */
|
||||
onupdate?(this: State, vnode: VnodeDOM<Attrs, State>): any;
|
||||
/** A key to optionally associate with this element. */
|
||||
key?: string | number | undefined;
|
||||
}
|
||||
|
||||
interface Hyperscript {
|
||||
/** Creates a virtual element (Vnode). */
|
||||
(selector: string, ...children: Children[]): Vnode<any, any>;
|
||||
/** Creates a virtual element (Vnode). */
|
||||
(selector: string, attributes: Attributes, ...children: Children[]): Vnode<any, any>;
|
||||
/** Creates a virtual element (Vnode). */
|
||||
<Attrs, State>(component: ComponentTypes<Attrs, State>, ...args: Children[]): Vnode<Attrs, State>;
|
||||
/** Creates a virtual element (Vnode). */
|
||||
<Attrs, State>(
|
||||
component: ComponentTypes<Attrs, State>,
|
||||
attributes: Attrs & CommonAttributes<Attrs, State>,
|
||||
...args: Children[]
|
||||
): Vnode<Attrs, State>;
|
||||
/** Creates a fragment virtual element (Vnode). */
|
||||
fragment(attrs: CommonAttributes<any, any> & { [key: string]: any }, children: ChildArrayOrPrimitive): Vnode<any, any>;
|
||||
/** Turns an HTML string into a virtual element (Vnode). Do not use trust on unsanitized user input. */
|
||||
trust(html: string): Vnode<any, any>;
|
||||
}
|
||||
|
||||
interface RouteResolver<Attrs = {}, State = {}> {
|
||||
/** The onmatch hook is called when the router needs to find a component to render. */
|
||||
onmatch?(
|
||||
this: this,
|
||||
args: Attrs,
|
||||
requestedPath: string,
|
||||
route: string,
|
||||
): ComponentTypes<any, any> | Promise<any> | void;
|
||||
/** The render method is called on every redraw for a matching route. */
|
||||
render?(this: this, vnode: Vnode<Attrs, State>): Children;
|
||||
}
|
||||
|
||||
/** This represents a key-value mapping linking routes to components. */
|
||||
interface RouteDefs {
|
||||
/** The key represents the route. The value represents the corresponding component. */
|
||||
[url: string]: ComponentTypes<any, any> | RouteResolver<any, any>;
|
||||
}
|
||||
|
||||
interface RouteOptions {
|
||||
/** Routing parameters. If path has routing parameter slots, the properties of this object are interpolated into the path string. */
|
||||
replace?: boolean | undefined;
|
||||
/** The state object to pass to the underlying history.pushState / history.replaceState call. */
|
||||
state?: any;
|
||||
/** The title string to pass to the underlying history.pushState / history.replaceState call. */
|
||||
title?: string | undefined;
|
||||
}
|
||||
|
||||
interface RouteLinkAttrs extends Attributes {
|
||||
href: string;
|
||||
selector?: string | ComponentTypes<any> | undefined;
|
||||
options?: RouteOptions | undefined;
|
||||
}
|
||||
|
||||
interface Route {
|
||||
/** Creates application routes and mounts Components and/or RouteResolvers to a DOM element. */
|
||||
(element: Element, defaultRoute: string, routes: RouteDefs): void;
|
||||
/** Returns the last fully resolved routing path, without the prefix. */
|
||||
get(): string;
|
||||
/** Redirects to a matching route or to the default route if no matching routes can be found. */
|
||||
set(route: string, data?: any, options?: RouteOptions): void;
|
||||
/** Defines a router prefix which is a fragment of the URL that dictates the underlying strategy used by the router. */
|
||||
prefix: string;
|
||||
/** This Component renders a link <a href> that will use the current routing strategy */
|
||||
Link: Component<RouteLinkAttrs>;
|
||||
/** Returns the named parameter value from the current route. */
|
||||
param(name: string): string;
|
||||
/** Gets all route parameters. */
|
||||
param(): any;
|
||||
}
|
||||
|
||||
interface RequestOptions<T> {
|
||||
/** The HTTP method to use. */
|
||||
method?: string | undefined;
|
||||
/** The data to be interpolated into the URL and serialized into the querystring. */
|
||||
params?: { [key: string]: any } | undefined;
|
||||
/** The data to be serialized into the request body. */
|
||||
body?: (XMLHttpRequest['send'] extends (x: infer R) => any ? R : never) | (object & { [id: string]: any }) | undefined;
|
||||
/** Whether the request should be asynchronous. Defaults to true. */
|
||||
async?: boolean | undefined;
|
||||
/** A username for HTTP authorization. */
|
||||
user?: string | undefined;
|
||||
/** A password for HTTP authorization. */
|
||||
password?: string | undefined;
|
||||
/** Whether to send cookies to 3rd party domains. */
|
||||
withCredentials?: boolean | undefined;
|
||||
/** Exposes the underlying XMLHttpRequest object for low-level configuration. */
|
||||
config?(xhr: XMLHttpRequest, options: this): XMLHttpRequest | void;
|
||||
/** Headers to append to the request before sending it. */
|
||||
headers?: { [key: string]: string } | undefined;
|
||||
/** A constructor to be applied to each object in the response. */
|
||||
type?: new (o: any) => any;
|
||||
/** A serialization method to be applied to data. Defaults to JSON.stringify, or if options.data is an instance of FormData, defaults to the identity function. */
|
||||
serialize?(data: any): any;
|
||||
/** A deserialization method to be applied to the response. Defaults to a small wrapper around JSON.parse that returns null for empty responses. */
|
||||
deserialize?(data: string): T;
|
||||
/** A hook to specify how the XMLHttpRequest response should be read. Useful for reading response headers and cookies. Defaults to a function that returns xhr.responseText */
|
||||
extract?(xhr: XMLHttpRequest, options: this): T;
|
||||
/**
|
||||
* Force the use of the HTTP body section for data in GET requests when set to true,
|
||||
* or the use of querystring for other HTTP methods when set to false.
|
||||
* Defaults to false for GET requests and true for other methods.
|
||||
*/
|
||||
useBody?: boolean | undefined;
|
||||
/** If false, redraws mounted components upon completion of the request. If true, it does not. */
|
||||
background?: boolean | undefined;
|
||||
/** Milliseconds a request can take before automatically being terminated. */
|
||||
timeout?: number | undefined;
|
||||
/** The expected type of the response, as a legal value of XMLHttpRequest.responseType. */
|
||||
responseType?: '' | 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | undefined;
|
||||
}
|
||||
|
||||
interface JsonpOptions {
|
||||
/** The data to be interpolated into the URL and serialized into the querystring. */
|
||||
params?: { [id: string]: any } | undefined;
|
||||
/** The data to be serialized into the request body. */
|
||||
body?: any;
|
||||
/** A constructor to be applied to each object in the response. */
|
||||
type?: new (o: any) => any;
|
||||
/** The name of the function that will be called as the callback. */
|
||||
callbackName?: string | undefined;
|
||||
/** The name of the querystring parameter name that specifies the callback name. */
|
||||
callbackKey?: string | undefined;
|
||||
/** If false, redraws mounted components upon completion of the request. If true, it does not. */
|
||||
background?: boolean | undefined;
|
||||
}
|
||||
|
||||
interface Redraw {
|
||||
/** Manually triggers an asynchronous redraw of mounted components. */
|
||||
(): void;
|
||||
/** Manually triggers a synchronous redraw of mounted components. */
|
||||
sync(): void;
|
||||
}
|
||||
|
||||
type Params = object & ParamsRec;
|
||||
|
||||
interface ParamsRec {
|
||||
// Ideally, it'd be this:
|
||||
// `[key: string | number]: Params | !symbol & !object`
|
||||
[key: string]: string | number | boolean | null | undefined | Params;
|
||||
}
|
||||
|
||||
interface Static extends Hyperscript {
|
||||
route: Route;
|
||||
mount: typeof mount;
|
||||
render: typeof render;
|
||||
redraw: Redraw;
|
||||
request: typeof request;
|
||||
jsonp: typeof jsonp;
|
||||
/** Returns an object with key/value pairs parsed from a string of the form: ?a=1&b=2 */
|
||||
parseQueryString(queryString: string): Params;
|
||||
/** Turns the key/value pairs of an object into a string of the form: a=1&b=2 */
|
||||
buildQueryString(values: Params): string;
|
||||
/** Parse path name */
|
||||
parsePathname(url: string): { path: string; params: Params };
|
||||
/** Build path name */
|
||||
buildPathname(template: string, params?: Params): string;
|
||||
}
|
||||
|
||||
// Vnode children types
|
||||
type Child = Vnode<any, any> | string | number | boolean | null | undefined;
|
||||
interface ChildArray extends Array<Children> {}
|
||||
type Children = Child | ChildArray;
|
||||
type ChildArrayOrPrimitive = ChildArray | string | number | boolean;
|
||||
|
||||
/** Virtual DOM nodes, or vnodes, are Javascript objects that represent an element (or parts of the DOM). */
|
||||
interface Vnode<Attrs = {}, State = {}> {
|
||||
/** The nodeName of a DOM element. It may also be the string [ if a vnode is a fragment, # if it's a text vnode, or < if it's a trusted HTML vnode. Additionally, it may be a component. */
|
||||
tag: string | ComponentTypes<Attrs, State>;
|
||||
/** A hashmap of DOM attributes, events, properties and lifecycle methods. */
|
||||
attrs: Attrs;
|
||||
/** An object that is persisted between redraws. In component vnodes, state is a shallow clone of the component object. */
|
||||
state: State;
|
||||
/** The value used to map a DOM element to its respective item in an array of data. */
|
||||
key?: string | number | undefined;
|
||||
/** In most vnode types, the children property is an array of vnodes. For text and trusted HTML vnodes, The children property is either a string, a number or a boolean. */
|
||||
children?: ChildArrayOrPrimitive | undefined;
|
||||
/**
|
||||
* This is used instead of children if a vnode contains a text node as its only child.
|
||||
* This is done for performance reasons.
|
||||
* Component vnodes never use the text property even if they have a text node as their only child.
|
||||
*/
|
||||
text?: string | number | boolean | undefined;
|
||||
}
|
||||
|
||||
// In some lifecycle methods, Vnode will have a dom property
|
||||
// and possibly a domSize property.
|
||||
interface VnodeDOM<Attrs = {}, State = {}> extends Vnode<Attrs, State> {
|
||||
/** Points to the element that corresponds to the vnode. */
|
||||
dom: Element;
|
||||
/** This defines the number of DOM elements that the vnode represents (starting from the element referenced by the dom property). */
|
||||
domSize?: number | undefined;
|
||||
}
|
||||
|
||||
type _NoLifecycle<T> = Omit<T, keyof Component>;
|
||||
|
||||
interface CVnode<A = {}> extends Vnode<A, ClassComponent<A>> {}
|
||||
|
||||
interface CVnodeDOM<A = {}> extends VnodeDOM<A, ClassComponent<A>> {}
|
||||
|
||||
/**
|
||||
* Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse.
|
||||
* Any Javascript object that has a view method can be used as a Mithril component.
|
||||
* Components can be consumed via the m() utility.
|
||||
*/
|
||||
interface Component<Attrs = {}, State = {}> {
|
||||
/** The oninit hook is called before a vnode is touched by the virtual DOM engine. */
|
||||
oninit?(this: _NoLifecycle<this & State>, vnode: Vnode<Attrs, _NoLifecycle<this & State>>): any;
|
||||
/** The oncreate hook is called after a DOM element is created and attached to the document. */
|
||||
oncreate?(this: _NoLifecycle<this & State>, vnode: VnodeDOM<Attrs, _NoLifecycle<this & State>>): any;
|
||||
/** The onbeforeremove hook is called before a DOM element is detached from the document. If a Promise is returned, Mithril only detaches the DOM element after the promise completes. */
|
||||
onbeforeremove?(this: _NoLifecycle<this & State>, vnode: VnodeDOM<Attrs, _NoLifecycle<this & State>>): Promise<any> | void;
|
||||
/** The onremove hook is called before a DOM element is removed from the document. */
|
||||
onremove?(this: _NoLifecycle<this & State>, vnode: VnodeDOM<Attrs, _NoLifecycle<this & State>>): any;
|
||||
/** The onbeforeupdate hook is called before a vnode is diffed in a update. */
|
||||
onbeforeupdate?(this: _NoLifecycle<this & State>, vnode: Vnode<Attrs, _NoLifecycle<this & State>>, old: VnodeDOM<Attrs, _NoLifecycle<this & State>>): boolean | void;
|
||||
/** The onupdate hook is called after a DOM element is updated, while attached to the document. */
|
||||
onupdate?(this: _NoLifecycle<this & State>, vnode: VnodeDOM<Attrs, _NoLifecycle<this & State>>): any;
|
||||
/** Creates a view out of virtual elements. */
|
||||
view(this: _NoLifecycle<this & State>, vnode: Vnode<Attrs, _NoLifecycle<this & State>>): Children | null | void;
|
||||
}
|
||||
|
||||
/**
|
||||
* Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse.
|
||||
* Any class that implements a view method can be used as a Mithril component.
|
||||
* Components can be consumed via the m() utility.
|
||||
*/
|
||||
interface ClassComponent<A = {}> {
|
||||
/** The oninit hook is called before a vnode is touched by the virtual DOM engine. */
|
||||
oninit?(vnode: Vnode<A, this>): any;
|
||||
/** The oncreate hook is called after a DOM element is created and attached to the document. */
|
||||
oncreate?(vnode: VnodeDOM<A, this>): any;
|
||||
/** The onbeforeremove hook is called before a DOM element is detached from the document. If a Promise is returned, Mithril only detaches the DOM element after the promise completes. */
|
||||
onbeforeremove?(vnode: VnodeDOM<A, this>): Promise<any> | void;
|
||||
/** The onremove hook is called before a DOM element is removed from the document. */
|
||||
onremove?(vnode: VnodeDOM<A, this>): any;
|
||||
/** The onbeforeupdate hook is called before a vnode is diffed in a update. */
|
||||
onbeforeupdate?(vnode: Vnode<A, this>, old: VnodeDOM<A, this>): boolean | void;
|
||||
/** The onupdate hook is called after a DOM element is updated, while attached to the document. */
|
||||
onupdate?(vnode: VnodeDOM<A, this>): any;
|
||||
/** Creates a view out of virtual elements. */
|
||||
view(vnode: Vnode<A, this>): Children | null | void;
|
||||
}
|
||||
|
||||
/**
|
||||
* Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse.
|
||||
* Any function that returns an object with a view method can be used as a Mithril component.
|
||||
* Components can be consumed via the m() utility.
|
||||
*/
|
||||
type FactoryComponent<A = {}> = (vnode: Vnode<A>) => Component<A>;
|
||||
|
||||
/**
|
||||
* Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse.
|
||||
* Any function that returns an object with a view method can be used as a Mithril component.
|
||||
* Components can be consumed via the m() utility.
|
||||
*/
|
||||
type ClosureComponent<A = {}> = FactoryComponent<A>;
|
||||
|
||||
/**
|
||||
* Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse.
|
||||
* Any Javascript object that has a view method is a Mithril component. Components can be consumed via the m() utility.
|
||||
*/
|
||||
type Comp<Attrs = {}, State = {}> = _NoLifecycle<State> & Component<Attrs, _NoLifecycle<State>>;
|
||||
|
||||
/** Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse. Components can be consumed via the m() utility. */
|
||||
type ComponentTypes<A = {}, S = {}> =
|
||||
| Component<A, S>
|
||||
| { new (vnode: CVnode<A>): ClassComponent<A> }
|
||||
| FactoryComponent<A>;
|
||||
|
||||
/** This represents the attributes available for configuring virtual elements, beyond the applicable DOM attributes. */
|
||||
interface Attributes extends CommonAttributes<any, any> {
|
||||
/** The class name(s) for this virtual element, as a space-separated list. */
|
||||
className?: string | undefined;
|
||||
/** The class name(s) for this virtual element, as a space-separated list. */
|
||||
class?: string | undefined;
|
||||
/** Any other virtual element properties, including attributes and event handlers. */
|
||||
[property: string]: any;
|
||||
}
|
||||
}
|
||||
|
||||
declare global {
|
||||
namespace JSX {
|
||||
// tslint:disable-next-line:no-empty-interface
|
||||
interface Element extends Mithril.Vnode {}
|
||||
|
||||
// tslint:disable-next-line:no-empty-interface
|
||||
interface IntrinsicAttributes extends Mithril.Attributes {}
|
||||
// tslint:disable-next-line:no-empty-interface
|
||||
interface IntrinsicClassAttributes extends Mithril.Attributes {}
|
||||
|
||||
interface IntrinsicElements {
|
||||
// HTML
|
||||
a: Mithril.Attributes;
|
||||
abbr: Mithril.Attributes;
|
||||
address: Mithril.Attributes;
|
||||
area: Mithril.Attributes;
|
||||
article: Mithril.Attributes;
|
||||
aside: Mithril.Attributes;
|
||||
audio: Mithril.Attributes;
|
||||
b: Mithril.Attributes;
|
||||
base: Mithril.Attributes;
|
||||
bdi: Mithril.Attributes;
|
||||
bdo: Mithril.Attributes;
|
||||
big: Mithril.Attributes;
|
||||
blockquote: Mithril.Attributes;
|
||||
body: Mithril.Attributes;
|
||||
br: Mithril.Attributes;
|
||||
button: Mithril.Attributes;
|
||||
canvas: Mithril.Attributes;
|
||||
caption: Mithril.Attributes;
|
||||
cite: Mithril.Attributes;
|
||||
code: Mithril.Attributes;
|
||||
col: Mithril.Attributes;
|
||||
colgroup: Mithril.Attributes;
|
||||
data: Mithril.Attributes;
|
||||
datalist: Mithril.Attributes;
|
||||
dd: Mithril.Attributes;
|
||||
del: Mithril.Attributes;
|
||||
details: Mithril.Attributes;
|
||||
dfn: Mithril.Attributes;
|
||||
dialog: Mithril.Attributes;
|
||||
div: Mithril.Attributes;
|
||||
dl: Mithril.Attributes;
|
||||
dt: Mithril.Attributes;
|
||||
em: Mithril.Attributes;
|
||||
embed: Mithril.Attributes;
|
||||
fieldset: Mithril.Attributes;
|
||||
figcaption: Mithril.Attributes;
|
||||
figure: Mithril.Attributes;
|
||||
footer: Mithril.Attributes;
|
||||
form: Mithril.Attributes;
|
||||
h1: Mithril.Attributes;
|
||||
h2: Mithril.Attributes;
|
||||
h3: Mithril.Attributes;
|
||||
h4: Mithril.Attributes;
|
||||
h5: Mithril.Attributes;
|
||||
h6: Mithril.Attributes;
|
||||
head: Mithril.Attributes;
|
||||
header: Mithril.Attributes;
|
||||
hgroup: Mithril.Attributes;
|
||||
hr: Mithril.Attributes;
|
||||
html: Mithril.Attributes;
|
||||
i: Mithril.Attributes;
|
||||
iframe: Mithril.Attributes;
|
||||
img: Mithril.Attributes;
|
||||
input: Mithril.Attributes;
|
||||
ins: Mithril.Attributes;
|
||||
kbd: Mithril.Attributes;
|
||||
keygen: Mithril.Attributes;
|
||||
label: Mithril.Attributes;
|
||||
legend: Mithril.Attributes;
|
||||
li: Mithril.Attributes;
|
||||
link: Mithril.Attributes;
|
||||
main: Mithril.Attributes;
|
||||
map: Mithril.Attributes;
|
||||
mark: Mithril.Attributes;
|
||||
menu: Mithril.Attributes;
|
||||
menuitem: Mithril.Attributes;
|
||||
meta: Mithril.Attributes;
|
||||
meter: Mithril.Attributes;
|
||||
nav: Mithril.Attributes;
|
||||
noindex: Mithril.Attributes;
|
||||
noscript: Mithril.Attributes;
|
||||
object: Mithril.Attributes;
|
||||
ol: Mithril.Attributes;
|
||||
optgroup: Mithril.Attributes;
|
||||
option: Mithril.Attributes;
|
||||
output: Mithril.Attributes;
|
||||
p: Mithril.Attributes;
|
||||
param: Mithril.Attributes;
|
||||
picture: Mithril.Attributes;
|
||||
pre: Mithril.Attributes;
|
||||
progress: Mithril.Attributes;
|
||||
q: Mithril.Attributes;
|
||||
rp: Mithril.Attributes;
|
||||
rt: Mithril.Attributes;
|
||||
ruby: Mithril.Attributes;
|
||||
s: Mithril.Attributes;
|
||||
samp: Mithril.Attributes;
|
||||
script: Mithril.Attributes;
|
||||
section: Mithril.Attributes;
|
||||
select: Mithril.Attributes;
|
||||
small: Mithril.Attributes;
|
||||
source: Mithril.Attributes;
|
||||
span: Mithril.Attributes;
|
||||
strong: Mithril.Attributes;
|
||||
style: Mithril.Attributes;
|
||||
sub: Mithril.Attributes;
|
||||
summary: Mithril.Attributes;
|
||||
sup: Mithril.Attributes;
|
||||
table: Mithril.Attributes;
|
||||
template: Mithril.Attributes;
|
||||
tbody: Mithril.Attributes;
|
||||
td: Mithril.Attributes;
|
||||
textarea: Mithril.Attributes;
|
||||
tfoot: Mithril.Attributes;
|
||||
th: Mithril.Attributes;
|
||||
thead: Mithril.Attributes;
|
||||
time: Mithril.Attributes;
|
||||
title: Mithril.Attributes;
|
||||
tr: Mithril.Attributes;
|
||||
track: Mithril.Attributes;
|
||||
u: Mithril.Attributes;
|
||||
ul: Mithril.Attributes;
|
||||
var: Mithril.Attributes;
|
||||
video: Mithril.Attributes;
|
||||
wbr: Mithril.Attributes;
|
||||
webview: Mithril.Attributes;
|
||||
|
||||
// SVG
|
||||
svg: Mithril.Attributes;
|
||||
animate: Mithril.Attributes;
|
||||
animateMotion: Mithril.Attributes;
|
||||
animateTransform: Mithril.Attributes;
|
||||
circle: Mithril.Attributes;
|
||||
clipPath: Mithril.Attributes;
|
||||
defs: Mithril.Attributes;
|
||||
desc: Mithril.Attributes;
|
||||
ellipse: Mithril.Attributes;
|
||||
feBlend: Mithril.Attributes;
|
||||
feColorMatrix: Mithril.Attributes;
|
||||
feComponentTransfer: Mithril.Attributes;
|
||||
feComposite: Mithril.Attributes;
|
||||
feConvolveMatrix: Mithril.Attributes;
|
||||
feDiffuseLighting: Mithril.Attributes;
|
||||
feDisplacementMap: Mithril.Attributes;
|
||||
feDistantLight: Mithril.Attributes;
|
||||
feDropShadow: Mithril.Attributes;
|
||||
feFlood: Mithril.Attributes;
|
||||
feFuncA: Mithril.Attributes;
|
||||
feFuncB: Mithril.Attributes;
|
||||
feFuncG: Mithril.Attributes;
|
||||
feFuncR: Mithril.Attributes;
|
||||
feGaussianBlur: Mithril.Attributes;
|
||||
feImage: Mithril.Attributes;
|
||||
feMerge: Mithril.Attributes;
|
||||
feMergeNode: Mithril.Attributes;
|
||||
feMorphology: Mithril.Attributes;
|
||||
feOffset: Mithril.Attributes;
|
||||
fePointLight: Mithril.Attributes;
|
||||
feSpecularLighting: Mithril.Attributes;
|
||||
feSpotLight: Mithril.Attributes;
|
||||
feTile: Mithril.Attributes;
|
||||
feTurbulence: Mithril.Attributes;
|
||||
filter: Mithril.Attributes;
|
||||
foreignObject: Mithril.Attributes;
|
||||
g: Mithril.Attributes;
|
||||
image: Mithril.Attributes;
|
||||
line: Mithril.Attributes;
|
||||
linearGradient: Mithril.Attributes;
|
||||
marker: Mithril.Attributes;
|
||||
mask: Mithril.Attributes;
|
||||
metadata: Mithril.Attributes;
|
||||
mpath: Mithril.Attributes;
|
||||
path: Mithril.Attributes;
|
||||
pattern: Mithril.Attributes;
|
||||
polygon: Mithril.Attributes;
|
||||
polyline: Mithril.Attributes;
|
||||
radialGradient: Mithril.Attributes;
|
||||
rect: Mithril.Attributes;
|
||||
stop: Mithril.Attributes;
|
||||
switch: Mithril.Attributes;
|
||||
symbol: Mithril.Attributes;
|
||||
text: Mithril.Attributes;
|
||||
textPath: Mithril.Attributes;
|
||||
tspan: Mithril.Attributes;
|
||||
use: Mithril.Attributes;
|
||||
view: Mithril.Attributes;
|
||||
|
||||
// Special Mithril types
|
||||
'[': Mithril.Attributes;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
declare const Mithril: Mithril.Static;
|
||||
export = Mithril;
|
||||
43
js/dist-typings/@types/mithril/stream/index.d.ts
vendored
Normal file
43
js/dist-typings/@types/mithril/stream/index.d.ts
vendored
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
// tslint:disable:rulename strict-export-declare-modifiers
|
||||
/** Creates an empty stream. */
|
||||
declare function Stream<T>(): Stream<T>; // tslint:disable-line no-unnecessary-generics
|
||||
/** Creates a stream with an initial value. */
|
||||
declare function Stream<T>(value: T): Stream<T>; // tslint:disable-line unified-signatures
|
||||
|
||||
declare interface Stream<T> {
|
||||
/** Returns the value of the stream. */
|
||||
(): T;
|
||||
/** Sets the value of the stream. */
|
||||
(value: T): this;
|
||||
/** Creates a dependent stream whose value is set to the result of the callback function. */
|
||||
map<U>(f: (current: T) => U | typeof Stream.SKIP): Stream<U>;
|
||||
/** This method is functionally identical to stream. It exists to conform to Fantasy Land's Applicative specification. */
|
||||
of(val: T): Stream<T>;
|
||||
/** Apply. */
|
||||
ap<U>(f: Stream<(value: T) => U>): Stream<U>;
|
||||
/** A co-dependent stream that unregisters dependent streams when set to true. */
|
||||
end: Stream<boolean>;
|
||||
/** When a stream is passed as the argument to JSON.stringify(), the value of the stream is serialized. */
|
||||
toJSON(): string;
|
||||
/** Returns the value of the stream. */
|
||||
valueOf(): T;
|
||||
}
|
||||
|
||||
declare namespace Stream {
|
||||
/** Creates a computed stream that reactively updates if any of its upstreams are updated. */
|
||||
export function combine<T>(combiner: (...streams: any[]) => T, streams: Array<Stream<any>>): Stream<T>;
|
||||
/** Combines the values of one or more streams into a single stream that is updated whenever one or more of the sources are updated */
|
||||
export function lift<S extends any[], T>(fn: (...values: S) => T, ...streams: {[I in keyof S]: Stream<S[I]>}): Stream<T>;
|
||||
/** Creates a stream whose value is the array of values from an array of streams. */
|
||||
export function merge<S extends any[]>(streams: {[I in keyof S]: Stream<S[I]>}): Stream<{[I in keyof S]: S[I]}>;
|
||||
/** Creates a new stream with the results of calling the function on every incoming stream with and accumulator and the incoming value. */
|
||||
export function scan<T, U>(fn: (acc: U, value: T) => U, acc: U, stream: Stream<T>): Stream<U>;
|
||||
/** Takes an array of pairs of streams and scan functions and merges all those streams using the given functions into a single stream. */
|
||||
export function scanMerge<T, U>(pairs: Array<[Stream<T>, (acc: U, value: T) => U]>, acc: U): Stream<U>;
|
||||
/** Takes an array of pairs of streams and scan functions and merges all those streams using the given functions into a single stream. */
|
||||
export function scanMerge<U>(pairs: Array<[Stream<any>, (acc: U, value: any) => U]>, acc: U): Stream<U>;
|
||||
/** A special value that can be returned to stream callbacks to skip execution of downstreams. */
|
||||
export const SKIP: unique symbol;
|
||||
}
|
||||
|
||||
export = Stream;
|
||||
|
|
@ -1,4 +1,3 @@
|
|||
/// <reference types="mithril" />
|
||||
import Component, { ComponentAttrs } from '../Component';
|
||||
export interface LoadingIndicatorAttrs extends ComponentAttrs {
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
/// <reference types="mithril" />
|
||||
import type RequestError from '../utils/RequestError';
|
||||
import Modal, { IInternalModalAttrs } from './Modal';
|
||||
export interface IRequestErrorModalAttrs extends IInternalModalAttrs {
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user