@mappable-world/mappable-types 0.0.1

package/packages/spherical-mercator-projection/index.d.ts

@@ -0,0 +1,38 @@
+import type { Projection } from "../../common/types";
+/**
+ * @class Mercator projection onto a sphere.
+ * Used by many mapping services, in particular OpenStreetMap.
+ * @name projection.sphericalMercator
+ * @augments Projection
+ * @static
+ * @example
+ * ```js
+ * const { SphericalMercator } = await mappable.import('@mappable/mappable-spherical-mercator-projection@0.0.1');
+ * // Create a map in the spherical Mercator projection
+ * const map = new mappable.MMap(document.getElementById('MMapsID'), {
+ *     location: {
+ *         center: [37, 55],
+ *          zoom: 6
+ *     },
+ *     projection: new SphericalMercator()
+ * });
+ * const dataSourceProps = {
+ *     raster: {
+ *         type: 'ground',
+ *         fetchTile: "https://tile.openstreetmap.org/{{z}}/{{y}}/{{x}}"
+ *     }
+ * };
+ * // Add osm tiles
+ * const dataSource = new mappable.MMapTileDataSource({
+ *     id: "osmSource",
+ *     ...dataSourceProps,
+ * });
+ *
+ * const layer = new mappable.MMapLayer({
+ *     id: "osm",
+ *     source: "osmSource",
+ *     type: "ground",
+ * });
+ * ```
+ */
+export declare const SphericalMercator: new () => Projection;

package/packages/types.d.ts

@@ -0,0 +1,11 @@
+import "../import";
+declare module "../import" {
+    interface Import {
+        (pkg: "@mappable/mappable-cartesian-projection@0.0.1"): Promise<typeof import("./cartesian-projection")>;
+        (pkg: "@mappable/mappable-spherical-mercator-projection@0.0.1"): Promise<typeof import("./spherical-mercator-projection")>;
+        (pkg: "@mappable/mappable-controls@0.0.1"): Promise<typeof import("./controls")>;
+        (pkg: "@mappable/mappable-markers@0.0.1"): Promise<typeof import("./markers")>;
+        (pkg: "@mappable/mappable-hint@0.0.1"): Promise<typeof import("./hint")>;
+        (pkg: "@mappable/mappable-clusterer@0.0.1"): Promise<typeof import("./clusterer")>;
+    }
+}

package/react/index.d.ts

@@ -0,0 +1,7 @@
+import { Reactify, ReactifiedEntity, ReactifiedModule } from "../reactify";
+type Module = ReactifiedModule<typeof import("../main")>;
+declare const module: Module & {
+    reactify: Reactify;
+    MMapReactContainer: ReactifiedEntity<typeof import("../imperative/MMapReactContainer").MMapReactContainer>;
+};
+export = module;

package/reactify/index.d.ts

@@ -0,0 +1,10 @@
+import type { Reactify, ReactifyEntity, ReactifiedEntity, ReactifyModule, ReactifiedModule } from "./reactify";
+import { overrideKey } from "./reactify";
+type TReact = typeof import("react");
+type TReactDOM = typeof import("react-dom");
+export type { Reactify, ReactifyEntity, ReactifiedEntity, ReactifyModule, ReactifiedModule };
+export type GenericReactify = {
+    readonly overrideKey: typeof overrideKey;
+    bindTo(React: TReact, ReactDOM: TReactDOM): Reactify;
+};
+export declare const reactify: Readonly<GenericReactify>;

package/reactify/overrides/MMap.d.ts

@@ -0,0 +1,18 @@
+import type TReact from "react";
+import type { CustomReactify } from "../reactify";
+import type { GenericRootEntity } from "../../imperative/Entities";
+import type { MMap as MMapI, MMapProps } from "../../imperative/MMap";
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            mappable: TReact.DetailedHTMLProps<TReact.HTMLAttributes<HTMLElement>, HTMLElement>;
+        }
+    }
+}
+type ComputedMMapProps = MMapProps & {
+    container: HTMLElement;
+};
+type MMapContainerProps = TReact.PropsWithChildren<MMapProps>;
+type MMapR = TReact.ForwardRefExoticComponent<MMapContainerProps & TReact.RefAttributes<GenericRootEntity<ComputedMMapProps>>>;
+export declare const MMapReactifyOverride: CustomReactify<MMapI, MMapR>;
+export {};

package/reactify/overrides/MMapControl.d.ts

@@ -0,0 +1,11 @@
+import type TReact from "react";
+import type { CustomReactify } from "../reactify";
+import type { GenericEntity } from "../../imperative/Entities";
+import type { MMapControl as MMapControlI, MMapControlProps } from "../../imperative/MMapControl";
+type ComputedMMapControlProps = MMapControlProps & {
+    controlElement: HTMLElement;
+};
+type MMapControlContainerProps = TReact.PropsWithChildren<MMapControlProps>;
+type MMapControlR = TReact.ForwardRefExoticComponent<MMapControlContainerProps & React.RefAttributes<GenericEntity<ComputedMMapControlProps>>>;
+export declare const MMapControlReactifyOverride: CustomReactify<MMapControlI, MMapControlR>;
+export {};

package/reactify/overrides/MMapMarker.d.ts

@@ -0,0 +1,11 @@
+import type TReactNamespace from "react";
+import type { CustomReactify } from "../reactify";
+import type { GenericEntity } from "../../imperative/Entities";
+import type { MMapMarker as MMapMarkerI, MMapMarkerProps } from "../../imperative/MMapMarker";
+type ComputedMMapMarkerProps = MMapMarkerProps & {
+    markerElement?: HTMLElement;
+};
+type MMapMarkerContainerProps = TReactNamespace.PropsWithChildren<ComputedMMapMarkerProps>;
+type MMapMarkerR = TReactNamespace.ForwardRefExoticComponent<MMapMarkerContainerProps & React.RefAttributes<GenericEntity<ComputedMMapMarkerProps>>>;
+export declare const MMapMarkerReactifyOverride: CustomReactify<MMapMarkerI, MMapMarkerR>;
+export {};

package/reactify/overrides/MMapReactContainer.d.ts

@@ -0,0 +1,6 @@
+import type TReact from "react";
+import type { CustomReactify } from "../reactify";
+import type { MMapReactContainer, MMapReactContainerProps } from "../../imperative/MMapReactContainer";
+type ReactProps<T> = TReact.PropsWithChildren<MMapReactContainerProps<T>>;
+export declare const MMapReactContainerReactifyOverride: CustomReactify<MMapReactContainer, TReact.FC<ReactProps<unknown>>>;
+export {};

package/reactify/overrides/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./MMap";
+export * from "./MMapControl";
+export * from "./MMapMarker";
+export * from "./MMapReactContainer";

package/reactify/reactify.d.ts

@@ -0,0 +1,43 @@
+import type TReact from "react";
+import type TReactDOM from "react-dom";
+import { GenericEntity, Context, EntityConstructor, EntityProps } from "../imperative/Entities";
+type RefInstance<TEntity extends GenericEntity<unknown>> = React.MutableRefObject<TEntity | undefined>;
+interface ReactParent {
+    entityRef: RefInstance<GenericEntity<unknown>>;
+    requestReposition(): void;
+    positionChild(entity: RefInstance<GenericEntity<unknown>>): number;
+}
+export declare let ReactParent: React.Context<[
+    ReactParent
+] | undefined>;
+export type Reactify = {
+    module: ReactifyModule;
+    entity: ReactifyEntity;
+};
+export declare const moduleOverrideExport: string;
+export declare const overrideKey: unique symbol;
+export type CustomReactify<TEntity extends GenericEntity<unknown>, TResult> = (ctor: EntityConstructor<TEntity>, params: {
+    reactify: {
+        module: <TModule extends BaseModule>(module: TModule) => ReactifiedModule<TModule>;
+        entity<T extends EntityConstructor<GenericEntity<unknown>> = EntityConstructor<TEntity>>(...args: Parameters<InternalReactifyEntity<T>>): ReturnType<InternalReactifyEntity<T>>;
+        context: <TContext extends Context<unknown>>(context?: TContext) => TReact.Context<unknown>;
+    };
+    ReactParent: typeof ReactParent;
+    React: typeof TReact;
+    ReactDOM: typeof TReactDOM;
+}) => TResult;
+export type Overrided<TReactResult> = {
+    [overrideKey]: CustomReactify<GenericEntity<unknown>, TReactResult>;
+};
+type InternalReactify<TEntity extends GenericEntity<unknown>> = (ctor: EntityConstructor<TEntity>, displayName?: string) => TReact.ForwardRefExoticComponent<TReact.PropsWithoutRef<TReact.PropsWithChildren<EntityProps<TEntity>>> & React.RefAttributes<TEntity | undefined>>;
+type InternalReactifyEntity<TCtor extends EntityConstructor<GenericEntity<unknown>>> = (ctor: TCtor, displayName?: string) => TCtor extends Overrided<infer TResult> ? TResult : ReturnType<InternalReactify<InstanceType<TCtor>>>;
+export type ReactifyEntity = <TCtor extends EntityConstructor<GenericEntity<unknown>>>(...args: Parameters<InternalReactifyEntity<TCtor>>) => ReturnType<InternalReactifyEntity<TCtor>>;
+export type ReactifiedEntity<TCtor extends EntityConstructor<GenericEntity<unknown>>> = ReturnType<InternalReactifyEntity<TCtor>>;
+export type ReactifyModule = <TModule extends BaseModule>(module: TModule) => ReactifiedModule<TModule>;
+export type GetReactContext<TContext extends Context<unknown>> = (context?: TContext | undefined) => React.Context<unknown>;
+export type ReactifiedModule<TModule extends BaseModule> = {
+    [Property in keyof TModule]: TModule[Property] extends EntityConstructor<GenericEntity<unknown>> ? ReturnType<InternalReactifyEntity<TModule[Property]>> : TModule[Property] extends typeof Context ? ReturnType<GetReactContext<TModule[Property]>> : TModule[Property];
+};
+export type BaseModule = Record<string | symbol, unknown>;
+export default function createReactify(React: typeof TReact, ReactDOM: typeof TReactDOM): Reactify;
+export {};