extra-map-card 1.0.0 → 1.0.2

package/dist/types/config.d.ts

@@ -0,0 +1,65 @@
+import { LngLatLike } from '@maptiler/sdk';
+import { HomeAssistant } from '@types';
+import { LovelaceCardConfig } from './ha-frontend/lovelace/lovelace';
+export interface EntityConfig {
+    entity: string;
+    type?: string;
+    name?: string;
+    icon?: string;
+    image?: string;
+    color?: string;
+}
+export interface MapEntityConfig extends EntityConfig {
+    label_mode?: 'state' | 'attribute' | 'name';
+    attribute?: string;
+    focus?: boolean;
+}
+export interface HaMapEntity {
+    entity_id: string;
+    color: string;
+    label_mode?: 'name' | 'state' | 'attribute' | 'icon';
+    attribute?: string;
+    name?: string;
+    focus?: boolean;
+}
+export interface HaMapPathPoint {
+    point: LngLatLike;
+    timestamp: Date;
+}
+export interface HaMapPaths {
+    points: HaMapPathPoint[];
+    color?: string;
+    name?: string;
+    gradualOpacity?: number;
+    fullDatetime?: boolean;
+}
+export interface HaEntityMarker extends HTMLElement {
+    hass?: HomeAssistant;
+    entityId?: string;
+    entityName?: string;
+    entityPicture?: string;
+    entityColor?: string;
+    showIcon?: boolean;
+}
+export interface CustomStyles {
+    light?: string;
+    dark?: string;
+}
+export type ThemeMode = 'auto' | 'light' | 'dark';
+export interface ExtraMapCardConfig extends LovelaceCardConfig {
+    type: 'custom:extra-map-card';
+    title?: string;
+    api_key?: string;
+    aspect_ratio?: string;
+    entities?: (MapEntityConfig | string)[];
+    auto_fit?: boolean;
+    fit_zones?: boolean;
+    default_zoom?: number;
+    hours_to_show?: number;
+    theme_mode?: ThemeMode;
+    light_theme?: string;
+    dark_theme?: string;
+    show_all?: boolean;
+    block_more_info?: boolean;
+    custom_styles?: CustomStyles;
+}

package/dist/types/ha-frontend/data/frontend-local-data.d.ts

@@ -0,0 +1,43 @@
+export declare enum NumberFormat {
+    language = "language",
+    system = "system",
+    comma_decimal = "comma_decimal",
+    decimal_comma = "decimal_comma",
+    space_comma = "space_comma",
+    none = "none"
+}
+export declare enum TimeFormat {
+    language = "language",
+    system = "system",
+    am_pm = "12",
+    twenty_four = "24"
+}
+export declare enum TimeZone {
+    local = "local",
+    server = "server"
+}
+export declare enum DateFormat {
+    language = "language",
+    system = "system",
+    DMY = "DMY",
+    MDY = "MDY",
+    YMD = "YMD"
+}
+export declare enum FirstWeekday {
+    language = "language",
+    monday = "monday",
+    tuesday = "tuesday",
+    wednesday = "wednesday",
+    thursday = "thursday",
+    friday = "friday",
+    saturday = "saturday",
+    sunday = "sunday"
+}
+export interface FrontendLocaleData {
+    language: string;
+    number_format: NumberFormat;
+    time_format: TimeFormat;
+    date_format: DateFormat;
+    first_weekday: FirstWeekday;
+    time_zone: TimeZone;
+}

package/dist/types/ha-frontend/data/history.d.ts

@@ -0,0 +1,21 @@
+import { HomeAssistant } from '../home-assistant';
+export type HistoryStates = Record<string, EntityHistoryState[]>;
+export interface EntityHistoryState {
+    /** state */
+    s: string;
+    /** attributes */
+    a: Record<string, any>;
+    /** last_changed; if set, also applies to lu */
+    lc?: number;
+    /** last_updated */
+    lu: number;
+}
+export interface HistoryStreamMessage {
+    states: HistoryStates;
+    start_time?: number;
+    end_time?: number;
+}
+export declare const entityIdHistoryNeedsAttributes: (hass: HomeAssistant, entityId: string) => boolean;
+export declare const fetchDateWS: (hass: HomeAssistant, startTime: Date, endTime: Date, entityIds: string[]) => Promise<HistoryStates>;
+export declare const subscribeHistoryStatesTimeWindow: (hass: HomeAssistant, callbackFunction: (data: HistoryStates) => void, hoursToShow: number, entityIds: string[], noAttributes?: boolean, minimalResponse?: boolean, significantChangesOnly?: boolean) => Promise<() => Promise<void>>;
+export declare const subscribeHistory: (hass: HomeAssistant, callbackFunction: (data: HistoryStates) => void, startTime: Date, endTime: Date, entityIds: string[]) => Promise<() => Promise<void>>;

package/dist/types/ha-frontend/data/image.d.ts

@@ -0,0 +1,9 @@
+import type { HassEntityAttributeBase, HassEntityBase } from "home-assistant-js-websocket";
+interface ImageEntityAttributes extends HassEntityAttributeBase {
+    access_token: string;
+}
+export interface ImageEntity extends HassEntityBase {
+    attributes: ImageEntityAttributes;
+}
+export declare const computeImageUrl: (entity: ImageEntity) => string;
+export {};

package/dist/types/ha-frontend/data/image_upload.d.ts

@@ -0,0 +1,21 @@
+import type { HomeAssistant } from '../../ha-frontend/home-assistant';
+interface Image {
+    filesize: number;
+    name: string;
+    uploaded_at: string;
+    content_type: string;
+    id: string;
+}
+export declare const URL_PREFIX = "/api/image/serve/";
+export declare const MEDIA_PREFIX = "media-source://image_upload";
+export interface ImageMutableParams {
+    name: string;
+}
+export declare const getIdFromUrl: (url: string) => string | undefined;
+export declare const generateImageThumbnailUrl: (mediaId: string, size?: number, original?: boolean) => string;
+export declare const fetchImages: (hass: HomeAssistant) => Promise<Image[]>;
+export declare const createImage: (hass: HomeAssistant, file: File) => Promise<Image>;
+export declare const updateImage: (hass: HomeAssistant, id: string, updates: Partial<ImageMutableParams>) => Promise<Image>;
+export declare const deleteImage: (hass: HomeAssistant, id: string) => Promise<unknown>;
+export declare const getImageData: (url: string) => Promise<Blob>;
+export {};

package/dist/types/ha-frontend/data/ws-templates.d.ts

@@ -0,0 +1,19 @@
+import { Connection, UnsubscribeFunc } from 'home-assistant-js-websocket';
+export interface RenderTemplateResult {
+    result: string;
+    listeners: TemplateListeners;
+}
+interface TemplateListeners {
+    all: boolean;
+    domains: string[];
+    entities: string[];
+    time: boolean;
+}
+export declare const subscribeRenderTemplate: (conn: Connection, onChange: (result: RenderTemplateResult) => void, params: {
+    template: string;
+    entity_ids?: string | string[];
+    variables?: Record<string, unknown>;
+    timeout?: number;
+    strict?: boolean;
+}) => Promise<UnsubscribeFunc>;
+export {};

package/dist/types/ha-frontend/data/ws-themes.d.ts

@@ -0,0 +1,27 @@
+import { Connection } from 'home-assistant-js-websocket';
+export interface ThemeSettings {
+    theme: string;
+    dark?: boolean;
+    primaryColor?: string;
+    accentColor?: string;
+}
+export interface ThemeVars {
+    'primary-color': string;
+    'text-primary-color': string;
+    'accent-color': string;
+    [key: string]: string;
+}
+export type Theme = ThemeVars & {
+    modes?: {
+        light?: ThemeVars;
+        dark?: ThemeVars;
+    };
+};
+export interface Themes {
+    default_theme: string;
+    default_dark_theme: string | null;
+    themes: Record<string, Theme>;
+    darkMode: boolean;
+    theme: string;
+}
+export declare const subscribeThemes: (conn: Connection, onChange: (themes: Themes) => void) => import("home-assistant-js-websocket").UnsubscribeFunc;

package/dist/types/ha-frontend/fire-event.d.ts

@@ -0,0 +1,28 @@
+declare global {
+    interface HASSDomEvents {
+    }
+}
+export type ValidHassDomEvent = keyof HASSDomEvents;
+export interface HASSDomEvent<T> extends Event {
+    detail: T;
+}
+/**
+ * Dispatches a custom event with an optional detail value.
+ *
+ * @param {string} type Name of event type.
+ * @param {*=} detail Detail value containing event-specific
+ *   payload.
+ * @param {{ bubbles: (boolean|undefined),
+ *           cancelable: (boolean|undefined),
+ *           composed: (boolean|undefined) }=}
+ *  options Object specifying options.  These may include:
+ *  `bubbles` (boolean, defaults to `true`),
+ *  `cancelable` (boolean, defaults to false), and
+ *  `node` on which to fire the event (HTMLElement, defaults to `this`).
+ * @return {Event} The new event that was fired.
+ */
+export declare const fireEvent: <HassEvent extends ValidHassDomEvent>(node: HTMLElement | Window, type: HassEvent, detail?: HASSDomEvents[HassEvent], options?: {
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+}) => Event;

package/dist/types/ha-frontend/home-assistant.d.ts

@@ -0,0 +1,70 @@
+import { Auth, Connection, HassConfig, HassEntities, HassEntity, HassServices, HassServiceTarget, MessageBase } from 'home-assistant-js-websocket';
+import { FrontendLocaleData } from './data/frontend-local-data';
+import { Themes, ThemeSettings } from './data/ws-themes';
+export interface Resources {
+    [language: string]: Record<string, string>;
+}
+export interface Context {
+    id: string;
+    parent_id?: string;
+    user_id?: string | null;
+}
+export interface ServiceCallResponse {
+    context: Context;
+    response?: any;
+}
+export interface ServiceCallRequest {
+    domain: string;
+    service: string;
+    serviceData?: Record<string, any>;
+    target?: HassServiceTarget;
+}
+export interface HomeAssistant {
+    auth: Auth & {
+        external?: any;
+    };
+    connection: Connection;
+    connected: boolean;
+    states: HassEntities;
+    entities: {
+        [id: string]: any;
+    };
+    devices: {
+        [id: string]: any;
+    };
+    areas: {
+        [id: string]: any;
+    };
+    services: HassServices;
+    config: HassConfig;
+    themes: Themes;
+    selectedTheme: ThemeSettings | null;
+    panels: any;
+    panelUrl: string;
+    language: string;
+    selectedLanguage: string | null;
+    locale: FrontendLocaleData;
+    resources: Resources;
+    localize: any;
+    translationMetadata: any;
+    suspendWhenHidden: boolean;
+    enableShortcuts: boolean;
+    vibrate: boolean;
+    debugConnection: boolean;
+    dockedSidebar: 'docked' | 'always_hidden' | 'auto';
+    defaultPanel: string;
+    moreInfoEntityId: string | null;
+    user?: any;
+    userData?: any;
+    hassUrl(path?: any): string;
+    callService(domain: ServiceCallRequest['domain'], service: ServiceCallRequest['service'], serviceData?: ServiceCallRequest['serviceData'], target?: ServiceCallRequest['target'], notifyOnError?: boolean, returnResponse?: boolean): Promise<ServiceCallResponse>;
+    callApi<T>(method: 'GET' | 'POST' | 'PUT' | 'DELETE', path: string, parameters?: Record<string, any>, headers?: Record<string, string>): Promise<T>;
+    fetchWithAuth(path: string, init?: Record<string, any>): Promise<Response>;
+    sendWS(msg: MessageBase): void;
+    callWS<T>(msg: MessageBase): Promise<T>;
+    formatEntityState(stateObj: HassEntity, state?: string): string;
+    formatEntityAttributeValue(stateObj: HassEntity, attribute: string, value?: any): string;
+    formatEntityAttributeName(stateObj: HassEntity, attribute: string): string;
+}
+/** Return if a component is loaded. */
+export declare const isComponentLoaded: (hass: HomeAssistant, component: string) => boolean;

package/dist/types/ha-frontend/lovelace/lovelace.d.ts

@@ -0,0 +1,208 @@
+import { HomeAssistant } from './../home-assistant';
+import type { Connection } from 'home-assistant-js-websocket';
+export interface Lovelace {
+    config: LovelaceConfig;
+    rawConfig: LovelaceRawConfig;
+    editMode: boolean;
+    urlPath: string | null;
+    mode: 'generated' | 'yaml' | 'storage';
+    locale: any;
+    enableFullEditMode: () => void;
+    setEditMode: (editMode: boolean) => void;
+    saveConfig: (newConfig: LovelaceRawConfig) => Promise<void>;
+    deleteConfig: () => Promise<void>;
+    showToast: (params: any) => void;
+}
+export declare function getLovelace(): Lovelace | null;
+export declare function findCardIndex(card: any): Promise<string | null>;
+export type LovelaceCardPath = [number, number] | [number, number, number];
+export type LovelaceContainerPath = [number] | [number, number];
+export declare const parseLovelaceCardPath: (path: LovelaceCardPath) => {
+    viewIndex: number;
+    sectionIndex?: number;
+    cardIndex: number;
+};
+export declare const parseLovelaceContainerPath: (path: LovelaceContainerPath) => {
+    viewIndex: number;
+    sectionIndex?: number;
+};
+export declare const getLovelaceContainerPath: (path: LovelaceCardPath) => LovelaceContainerPath;
+type FindLovelaceContainer = {
+    (config: LovelaceConfig, path: [number]): LovelaceViewRawConfig;
+    (config: LovelaceConfig, path: [number, number]): LovelaceSectionRawConfig;
+    (config: LovelaceConfig, path: LovelaceContainerPath): LovelaceViewRawConfig | LovelaceSectionRawConfig;
+};
+export declare const findLovelaceContainer: FindLovelaceContainer;
+export declare const findLovelaceCards: (config: LovelaceConfig, path: LovelaceContainerPath) => LovelaceCardConfig[] | undefined;
+export declare const updateLovelaceContainer: (config: LovelaceConfig, path: LovelaceContainerPath, containerConfig: LovelaceViewRawConfig | LovelaceSectionRawConfig) => LovelaceConfig;
+export declare const updateLovelaceCards: (config: LovelaceConfig, path: LovelaceContainerPath, cards: LovelaceCardConfig[]) => LovelaceConfig;
+export interface LovelaceCardEditor extends LovelaceGenericElementEditor {
+    setConfig(config: LovelaceCardConfig): void;
+}
+export interface LovelaceGenericElementEditor<C = any> extends HTMLElement {
+    hass?: HomeAssistant;
+    lovelace?: LovelaceConfig;
+    context?: C;
+    setConfig(config: any): void;
+    focusYamlEditor?: () => void;
+}
+export interface LovelaceDashboardBaseConfig {
+}
+export interface LovelaceCard extends HTMLElement {
+    hass?: HomeAssistant;
+    isPanel?: boolean;
+    preview?: boolean;
+    layout?: string;
+    getCardSize(): number | Promise<number>;
+    getLayoutOptions?(): LovelaceLayoutOptions;
+    setConfig(config: LovelaceCardConfig): void;
+}
+export interface LovelaceConfig extends LovelaceDashboardBaseConfig {
+    background?: string;
+    views: LovelaceViewRawConfig[];
+}
+export interface LovelaceDashboardStrategyConfig extends LovelaceDashboardBaseConfig {
+    strategy: LovelaceStrategyConfig;
+}
+export interface LegacyLovelaceConfig extends LovelaceConfig {
+    resources?: LovelaceResource[];
+}
+export type LovelaceRawConfig = LovelaceConfig | LovelaceDashboardStrategyConfig;
+export declare function isStrategyDashboard(config: LovelaceRawConfig): config is LovelaceDashboardStrategyConfig;
+export declare const fetchConfig: (conn: Connection, urlPath: string | null, force: boolean) => Promise<LovelaceRawConfig>;
+export declare const saveConfig: (hass: HomeAssistant, urlPath: string | null, config: LovelaceRawConfig) => Promise<void>;
+export declare const deleteConfig: (hass: HomeAssistant, urlPath: string | null) => Promise<void>;
+export interface ShowViewConfig {
+    user?: string;
+}
+interface LovelaceViewBackgroundConfig {
+    image?: string;
+}
+export interface LovelaceBaseViewConfig {
+    index?: number;
+    title?: string;
+    path?: string;
+    icon?: string;
+    theme?: string;
+    panel?: boolean;
+    background?: string | LovelaceViewBackgroundConfig;
+    visible?: boolean | ShowViewConfig[];
+    subview?: boolean;
+    back_path?: string;
+    max_columns?: number;
+}
+export interface LovelaceViewConfig extends LovelaceBaseViewConfig {
+    type?: string;
+    badges?: Array<string | LovelaceBadgeConfig>;
+    cards?: LovelaceCardConfig[];
+    sections?: LovelaceSectionRawConfig[];
+}
+export interface LovelaceStrategyViewConfig extends LovelaceBaseViewConfig {
+    strategy: LovelaceStrategyConfig;
+}
+export type LovelaceViewRawConfig = LovelaceViewConfig | LovelaceStrategyViewConfig;
+export declare function isStrategyView(view: LovelaceViewRawConfig): view is LovelaceStrategyViewConfig;
+export interface LovelaceBaseSectionConfig {
+    visibility?: Condition[];
+    column_span?: number;
+    row_span?: number;
+    /**
+     * @deprecated Use heading card instead.
+     */
+    title?: string;
+}
+export interface LovelaceSectionConfig extends LovelaceBaseSectionConfig {
+    type?: string;
+    cards?: LovelaceCardConfig[];
+}
+export interface LovelaceStrategySectionConfig extends LovelaceBaseSectionConfig {
+    strategy: LovelaceStrategyConfig;
+}
+export type LovelaceSectionRawConfig = LovelaceSectionConfig | LovelaceStrategySectionConfig;
+export declare function isStrategySection(section: LovelaceSectionRawConfig): section is LovelaceStrategySectionConfig;
+export interface LovelaceStrategyConfig {
+    type: string;
+    [key: string]: any;
+}
+export interface LovelaceBadgeConfig {
+    type: string;
+    [key: string]: any;
+    visibility?: Condition[];
+}
+export declare const ensureBadgeConfig: (config: Partial<LovelaceBadgeConfig> | string) => LovelaceBadgeConfig;
+export interface LovelaceCardConfig {
+    index?: number;
+    view_index?: number;
+    view_layout?: any;
+    layout_options?: LovelaceLayoutOptions;
+    type: string;
+    [key: string]: any;
+    visibility?: Condition[];
+}
+export type LovelaceLayoutOptions = {
+    grid_columns?: number | 'full';
+    grid_rows?: number | 'auto';
+    grid_max_columns?: number;
+    grid_min_columns?: number;
+    grid_min_rows?: number;
+    grid_max_rows?: number;
+};
+export interface LovelaceGridOptions {
+    columns?: number | 'full';
+    rows?: number | 'auto';
+    max_columns?: number;
+    min_columns?: number;
+    min_rows?: number;
+    max_rows?: number;
+}
+export type Condition = NumericStateCondition | StateCondition | ScreenCondition | UserCondition | OrCondition | AndCondition;
+export interface LegacyCondition {
+    entity?: string;
+    state?: string | string[];
+    state_not?: string | string[];
+}
+interface BaseCondition {
+    condition: string;
+}
+export interface NumericStateCondition extends BaseCondition {
+    condition: 'numeric_state';
+    entity?: string;
+    below?: string | number;
+    above?: string | number;
+}
+export interface StateCondition extends BaseCondition {
+    condition: 'state';
+    entity?: string;
+    state?: string | string[];
+    state_not?: string | string[];
+}
+export interface ScreenCondition extends BaseCondition {
+    condition: 'screen';
+    media_query?: string;
+}
+export interface UserCondition extends BaseCondition {
+    condition: 'user';
+    users?: string[];
+}
+export interface OrCondition extends BaseCondition {
+    condition: 'or';
+    conditions?: Condition[];
+}
+export interface AndCondition extends BaseCondition {
+    condition: 'and';
+    conditions?: Condition[];
+}
+export type LovelaceResource = {
+    id: string;
+    type: 'css' | 'js' | 'module' | 'html';
+    url: string;
+};
+export type LovelaceResourcesMutableParams = {
+    res_type: LovelaceResource['type'];
+    url: string;
+};
+export declare const fetchResources: (conn: Connection) => Promise<LovelaceResource[]>;
+export declare const createResource: (hass: HomeAssistant, values: LovelaceResourcesMutableParams) => Promise<LovelaceResource>;
+export declare const updateResource: (hass: HomeAssistant, id: string, updates: Partial<LovelaceResourcesMutableParams>) => Promise<LovelaceResource>;
+export declare const deleteResource: (hass: HomeAssistant, id: string) => Promise<unknown>;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './ha-frontend/home-assistant';
+export * from './ha-frontend/lovelace/lovelace';
+export * from './ha-frontend/fire-event';
+export * from './ha-frontend/data/ws-templates';
+export * from './ha-frontend/data/history';
+export * from './config';

package/dist/utilities/colors.d.ts

@@ -0,0 +1,2 @@
+export declare const COLORS: string[];
+export declare function getColorByIndex(index: number): string;

package/dist/utilities/compute_state_name.d.ts

@@ -0,0 +1,5 @@
+import type { HassEntity } from 'home-assistant-js-websocket';
+/** Compute the object ID of a state. */
+export declare const computeObjectId: (entityId: string) => string;
+export declare const computeStateNameFromEntityAttributes: (entityId: string, attributes: Record<string, any>) => string;
+export declare const computeStateName: (stateObj: HassEntity) => string;

package/dist/utilities/find-entities.d.ts

@@ -0,0 +1,3 @@
+import type { HomeAssistant } from '@types';
+import type { HassEntity } from 'home-assistant-js-websocket';
+export declare const findEntities: (hass: HomeAssistant, maxEntities: number, entities: string[], entitiesFallback: string[], includeDomains?: string[], entityFilter?: (stateObj: HassEntity) => boolean) => any[];

package/dist/utilities/has-changed.d.ts

@@ -0,0 +1,19 @@
+import type { PropertyValues } from 'lit';
+type EntityCategory = 'config' | 'diagnostic';
+export interface EntityRegistryDisplayEntry {
+    entity_id: string;
+    name?: string;
+    icon?: string;
+    device_id?: string;
+    area_id?: string;
+    labels: string[];
+    hidden?: boolean;
+    entity_category?: EntityCategory;
+    translation_key?: string;
+    platform?: string;
+    display_precision?: number;
+}
+export declare function hasConfigChanged(element: any, changedProps: PropertyValues): boolean;
+export declare function hasConfigOrEntityChanged(element: any, changedProps: PropertyValues): boolean;
+export declare function hasConfigOrEntitiesChanged(element: any, changedProps: PropertyValues): boolean;
+export {};

package/dist/utilities/loader.d.ts

@@ -0,0 +1,3 @@
+import { HaMapEntity } from 'types/config';
+export declare const loadHaComponents: () => void;
+export declare const loadMapCard: (entities: string[] | HaMapEntity[]) => Promise<void>;

package/dist/utilities/map-utils.d.ts

@@ -0,0 +1,15 @@
+import { HomeAssistant } from '@types';
+import { HaMapEntity } from 'types/config';
+import { FrontendLocaleData, TimeZone } from 'types/ha-frontend/data/frontend-local-data';
+export interface Address {
+    streetNumber: string;
+    streetName: string;
+    sublocality: string;
+    city: string;
+}
+export declare const getEntityId: (entity: string | HaMapEntity) => string;
+export declare const getAddress: import("memoize-one").MemoizedFn<(lat: number, lng: number, apiKey: string) => Promise<Address | null>>;
+export declare const LOCAL_TIME_ZONE: string;
+export declare const resolveTimeZone: (option: TimeZone, serverTimeZone: string) => string;
+export declare const useAmPm: import("memoize-one").MemoizedFn<(locale: FrontendLocaleData) => boolean>;
+export declare const formatTimeWeekday: (dateObj: Date, locale: FrontendLocaleData, config: HomeAssistant["config"]) => string;

package/dist/utilities/parse-aspect-ratio.d.ts

@@ -0,0 +1,4 @@
+export default function parseAspectRatio(input: string): {
+    w: number;
+    h: number;
+} | null;

package/dist/utilities/process-config-entities.d.ts

@@ -0,0 +1,3 @@
+import type { EntityConfig } from '../types/config';
+export declare const isValidEntityId: (entityId: string) => boolean;
+export declare const processConfigEntities: <T extends EntityConfig>(entities: (T | string)[], checkEntityId?: boolean) => T[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "extra-map-card",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Lovelace custom map card for Home Assistant",
   "keywords": [
     "home-assistant",
@@ -14,15 +14,17 @@
   "author": "Viet Ngoc",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ngocjohn/extra-map-card",
+    "url": "git+https://github.com/ngocjohn/extra-map-card.git",
     "repo": "ngocjohn/extra-map-card"
   },
-  "main": "dist/extra-map-card.js",
-  "module": "dist/extra-map-card.js",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
-      "import": "./dist/extra-map-card.js"
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     }
   },
   "files": [