kylefang/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/zhigang1992/DefinitelyTyped.git synced 2026-05-24 13:59:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1 from DefinitelyTyped/master

Browse Source 
merge
This commit is contained in:
kerol2r20
2017-06-13 18:25:17 +08:00
committed by GitHub
parent 0bf3602c2b 9340ad9a47
commit 6385121e8e
5 changed files with 35 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
types/leaflet/index.d.ts vendored
View File

@@ -390,6 +390,7 @@ declare namespace L {
interface LayerOptions {
pane?: string;
attribution?: string;
}
interface InteractiveLayerOptions extends LayerOptions {

1
types/node/index.d.ts vendored
View File

@@ -495,6 +495,7 @@ declare namespace NodeJS {
on(event: "uncaughtException", listener: (error: Error) => void): this;
on(event: "unhandledRejection", listener: (reason: any, promise: Promise<any>) => void): this;
on(event: "warning", listener: (warning: Error) => void): this;
on(event: "message", listener: (message: any, sendHandle: any) => void): this;
on(event: Signals, listener: () => void): this;
once(event: "beforeExit", listener: (code: number) => void): this;

3
types/node/node-tests.ts
View File

@@ -1890,6 +1890,9 @@ namespace process_tests {
var module: NodeModule | undefined;
module = process.mainModule;
}
{
process.on("message", (req: any) => { });
}
}
///////////////////////////////////////////////////////////

56
types/react-leaflet/index.d.ts vendored
View File

@@ -1,8 +1,8 @@
// Type definitions for react-leaflet 1.1
// Project: https://github.com/PaulLeCam/react-leaflet
// Definitions by: Dave Leaver <https://github.com/danzel>, David Schneider <https://github.com/davschne>
// Definitions by: Dave Leaver <https://github.com/danzel>, David Schneider <https://github.com/davschne>, Yui T. <https://github.com/yuit>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.2
// TypeScript Version: 2.3
import * as Leaflet from 'leaflet';
import * as React from 'react';
@@ -143,7 +143,7 @@ export interface MapProps extends MapEvents, Leaflet.MapOptions, Leaflet.LocateO
zoom?: number;
}
export class Map<P extends MapProps, E extends Leaflet.Map> extends MapComponent<P, E> {
export class Map<P extends MapProps = MapProps, E extends Leaflet.Map = Leaflet.Map> extends MapComponent<P, E> {
className?: string;
container: HTMLDivElement;
getChildContext(): { layerContainer: E, map: E };
@@ -165,7 +165,7 @@ export interface PaneProps {
export interface PaneState {
name?: string;
}
export class Pane<P extends PaneProps, S extends PaneState> extends React.Component<P, S> {
export class Pane<P extends PaneProps = PaneProps, S extends PaneState = PaneState> extends React.Component<P, S> {
getChildContext(): { pane: string };
createPane(props: P): void;
removePane(): void;
@@ -181,7 +181,7 @@ export interface LayerContainer {
addLayer(layer: Leaflet.Layer): this;
removeLayer(layer: number | Leaflet.Layer): this;
}
export class MapLayer<P extends MapLayerProps, E extends Leaflet.Class> extends MapComponent<P, E> {
export class MapLayer<P extends MapLayerProps = MapLayerProps, E extends Leaflet.Class = Leaflet.Class> extends MapComponent<P, E> {
createLeafletElement(props: P): E;
updateLeafletElement(fromProps: P, toProps: P): void;
readonly layerContainer: LayerContainer | Leaflet.Map;
@@ -190,33 +190,33 @@ export class MapLayer<P extends MapLayerProps, E extends Leaflet.Class> extends
export interface GridLayerProps extends Leaflet.GridLayerOptions {
children?: Children;
}
export class GridLayer<P extends GridLayerProps, E extends Leaflet.GridLayer> extends MapLayer<P, E> {}
export class GridLayer<P extends GridLayerProps = GridLayerProps, E extends Leaflet.GridLayer = Leaflet.GridLayer> extends MapLayer<P, E> {}
export interface TileLayerProps extends TileLayerEvents, Leaflet.TileLayerOptions {
children?: Children;
url: string;
}
export class TileLayer<P extends TileLayerProps, E extends Leaflet.TileLayer> extends GridLayer<P, E> { }
export class TileLayer<P extends TileLayerProps = TileLayerProps, E extends Leaflet.TileLayer = Leaflet.TileLayer> extends GridLayer<P, E> { }
export interface WMSTileLayerProps extends TileLayerEvents, Leaflet.WMSOptions {
children?: Children;
url: string;
}
export class WMSTileLayer<P extends WMSTileLayerProps, E extends Leaflet.TileLayer.WMS> extends GridLayer<P, E> { }
export class WMSTileLayer<P extends WMSTileLayerProps = WMSTileLayerProps, E extends Leaflet.TileLayer.WMS = Leaflet.TileLayer.WMS> extends GridLayer<P, E> { }
export interface ImageOverlayProps extends Leaflet.ImageOverlayOptions {
bounds: Leaflet.LatLngBoundsExpression;
children?: Children;
url: string;
}
export class ImageOverlay<P extends ImageOverlayProps, E extends Leaflet.ImageOverlay> extends MapLayer<P, E> {
export class ImageOverlay<P extends ImageOverlayProps = ImageOverlayProps, E extends Leaflet.ImageOverlay = Leaflet.ImageOverlay> extends MapLayer<P, E> {
getChildContext(): { popupContainer: E };
}
export interface LayerGroupProps {
children?: Children;
}
export class LayerGroup<P extends LayerGroupProps, E extends Leaflet.LayerGroup> extends MapLayer<P, E> {
export class LayerGroup<P extends LayerGroupProps = LayerGroupProps, E extends Leaflet.LayerGroup = Leaflet.LayerGroup> extends MapLayer<P, E> {
getChildContext(): { layerContainer: E };
}
@@ -224,7 +224,7 @@ export interface MarkerProps extends MarkerEvents, Leaflet.MarkerOptions {
children?: Children;
position: Leaflet.LatLngExpression;
}
export class Marker<P extends MarkerProps, E extends Leaflet.Marker> extends MapLayer<P, E> {
export class Marker<P extends MarkerProps = MarkerProps, E extends Leaflet.Marker = Leaflet.Marker> extends MapLayer<P, E> {
getChildContext(): { popupContainer: E };
}
@@ -241,19 +241,19 @@ export interface CircleProps extends PathEvents, Leaflet.CircleMarkerOptions {
children?: Children;
radius: number;
}
export class Circle<P extends CircleProps, E extends Leaflet.Circle> extends Path<P, E> { }
export class Circle<P extends CircleProps = CircleProps, E extends Leaflet.Circle = Leaflet.Circle> extends Path<P, E> { }
export interface CircleMarkerProps extends PathEvents, Leaflet.CircleMarkerOptions {
center: Leaflet.LatLngExpression;
children?: Children;
radius: number;
}
export class CircleMarker<P extends CircleMarkerProps, E extends Leaflet.CircleMarker> extends Path<P, E> { }
export class CircleMarker<P extends CircleMarkerProps = CircleMarkerProps, E extends Leaflet.CircleMarker = Leaflet.CircleMarker> extends Path<P, E> { }
export interface FeatureGroupProps extends FeatureGroupEvents, Leaflet.PathOptions {
children?: Children;
}
export class FeatureGroup<P extends FeatureGroupProps, E extends Leaflet.FeatureGroup> extends Path<P, E> {
export class FeatureGroup<P extends FeatureGroupProps = FeatureGroupProps, E extends Leaflet.FeatureGroup = Leaflet.FeatureGroup> extends Path<P, E> {
getChildContext(): { layerContainer: E, popupContainer: E };
}
@@ -262,33 +262,33 @@ export interface GeoJSONProps extends FeatureGroupEvents, Leaflet.GeoJSONOptions
data: GeoJSON.GeoJsonObject;
style?: Leaflet.StyleFunction;
}
export class GeoJSON<P extends GeoJSONProps, E extends Leaflet.GeoJSON> extends Path<P, E> { }
export class GeoJSON<P extends GeoJSONProps = GeoJSONProps, E extends Leaflet.GeoJSON = Leaflet.GeoJSON> extends Path<P, E> { }
export interface PolylineProps extends PathEvents, Leaflet.PolylineOptions {
children?: Children;
positions: Leaflet.LatLngExpression[] | Leaflet.LatLngExpression[][];
}
export class Polyline<P extends PolylineProps, E extends Leaflet.Polyline> extends Path<P, E> { }
export class Polyline<P extends PolylineProps = PolylineProps, E extends Leaflet.Polyline = Leaflet.Polyline> extends Path<P, E> { }
export interface PolygonProps extends PathEvents, Leaflet.PolylineOptions {
children?: Children;
popupContainer?: Leaflet.FeatureGroup;
positions: Leaflet.LatLngExpression[] | Leaflet.LatLngExpression[][] | Leaflet.LatLngExpression[][][];
}
export class Polygon<P extends PolygonProps, E extends Leaflet.Polygon> extends Path<P, E> { }
export class Polygon<P extends PolygonProps = PolygonProps, E extends Leaflet.Polygon = Leaflet.Polygon> extends Path<P, E> { }
export interface RectangleProps extends PathEvents, Leaflet.PolylineOptions {
children?: Children;
bounds: Leaflet.LatLngBoundsExpression;
popupContainer?: Leaflet.FeatureGroup;
}
export class Rectangle<P extends RectangleProps, E extends Leaflet.Rectangle> extends Path<P, E> { }
export class Rectangle<P extends RectangleProps = RectangleProps, E extends Leaflet.Rectangle = Leaflet.Rectangle> extends Path<P, E> { }
export interface PopupProps extends Leaflet.PopupOptions {
children?: Children;
position?: Leaflet.LatLngExpression;
}
export class Popup<P extends PopupProps, E extends Leaflet.Popup> extends MapComponent<P, E> {
export class Popup<P extends PopupProps = PopupProps, E extends Leaflet.Popup = Leaflet.Popup> extends MapComponent<P, E> {
onPopupOpen(arg: { popup: E }): void;
onPopupClose(arg: { popup: E }): void;
renderPopupContent(): void;
@@ -298,7 +298,7 @@ export class Popup<P extends PopupProps, E extends Leaflet.Popup> extends MapCom
export interface TooltipProps extends Leaflet.TooltipOptions {
children?: Children;
}
export class Tooltip<P extends TooltipProps, E extends Leaflet.Tooltip> extends MapComponent<P, E> {
export class Tooltip<P extends TooltipProps = TooltipProps, E extends Leaflet.Tooltip = Leaflet.Tooltip> extends MapComponent<P, E> {
onTooltipOpen(arg: { tooltip: E }): void;
onTooltipClose(arg: { tooltip: E }): void;
renderTooltipContent(): void;
@@ -306,21 +306,21 @@ export class Tooltip<P extends TooltipProps, E extends Leaflet.Tooltip> extends
}
export type MapControlProps = Leaflet.ControlOptions;
export class MapControl<P extends MapControlProps, E extends Leaflet.Control> extends React.Component<P, {}> {
export class MapControl<P extends MapControlProps = MapControlProps, E extends Leaflet.Control = Leaflet.Control> extends React.Component<P, {}> {
leafletElement: E;
createLeafletElement(props: P): E;
updateLeafletElement(fromProps: P, toProps: P): void;
}
export type AttributionControlProps = Leaflet.Control.AttributionOptions;
export class AttributionControl<P extends AttributionControlProps, E extends Leaflet.Control.Attribution> extends MapControl<P, E> { }
export class AttributionControl<P extends AttributionControlProps = AttributionControlProps, E extends Leaflet.Control.Attribution = Leaflet.Control.Attribution> extends MapControl<P, E> { }
export interface LayersControlProps extends LayersControlEvents, Leaflet.Control.LayersOptions {
baseLayers?: Leaflet.Control.LayersObject;
children?: Children;
overlays?: Leaflet.Control.LayersObject;
}
export class LayersControl<P extends AttributionControlProps, E extends Leaflet.Control.Layers> extends MapControl<P, E> { }
export class LayersControl<P extends LayersControlProps = LayersControlProps, E extends Leaflet.Control.Layers = Leaflet.Control.Layers> extends MapControl<P, E> { }
export namespace LayersControl {
interface BaseControlledLayerProps {
@@ -334,18 +334,18 @@ export namespace LayersControl {
addOverlay?(layer: Leaflet.Layer, name: string, checked: boolean): void;
name: string;
}
class ControlledLayer<P extends BaseControlledLayerProps> extends React.Component<P, {}> {
class ControlledLayer<P extends BaseControlledLayerProps = BaseControlledLayerProps> extends React.Component<P, {}> {
layer?: Leaflet.Layer;
getChildContext(): { layerContainer: LayerContainer };
addLayer(): void;
removeLayer(layer: Leaflet.Layer): void;
}
class BaseLayer<P extends ControlledLayerProps> extends ControlledLayer<P> { }
class Overlay<P extends ControlledLayerProps> extends ControlledLayer<P> { }
class BaseLayer<P extends ControlledLayerProps = ControlledLayerProps> extends ControlledLayer<P> { }
class Overlay<P extends ControlledLayerProps = ControlledLayerProps> extends ControlledLayer<P> { }
}
export type ScaleControlProps = Leaflet.Control.ScaleOptions;
export class ScaleControl<P extends ScaleControlProps, E extends Leaflet.Control.Scale> extends MapControl<P, E> { }
export class ScaleControl<P extends ScaleControlProps = ScaleControlProps, E extends Leaflet.Control.Scale = Leaflet.Control.Scale> extends MapControl<P, E> { }
export type ZoomControlProps = Leaflet.Control.ZoomOptions;
export class ZoomControl<P extends ZoomControlProps, E extends Leaflet.Control.Zoom> extends MapControl<P, E> { }
export class ZoomControl<P extends ZoomControlProps = ZoomControlProps, E extends Leaflet.Control.Zoom = Leaflet.Control.Zoom> extends MapControl<P, E> { }

4
types/react-leaflet/react-leaflet-tests.tsx
View File

@@ -686,7 +686,7 @@ class CenterControl extends MapControl<MapControlProps, Leaflet.Control> { // n
const centerControl = new L.Control({ position: 'bottomright' }); // see http://leafletjs.com/reference.html#control-positions for other positions
const jsx = (
// PUT YOUR JSX FOR THE COMPONENT HERE:
<div {...this.props}>
<div>
{/* add your JSX */}
</div>
);
@@ -713,7 +713,7 @@ class LegendControl extends MapControl<MapControlProps & { className?: string },
componentWillMount() {
const legend = new L.Control({ position: 'bottomright' });
const jsx = (
<div {...this.props}>
<div>
{this.props.children}
</div>
);