@basmilius/homey-common 0.0.1

package/src/decorator.ts

@@ -0,0 +1,41 @@
+import type { Constructor } from './types';
+
+export function action(id: string) {
+    return <T extends Constructor>(ActionClass: T): T => {
+        return class extends ActionClass {
+            get actionId(): string {
+                return id;
+            }
+        };
+    };
+}
+
+export function autocomplete(id: string) {
+    return <T extends Constructor>(AutocompleteClass: T): T => {
+        return class extends AutocompleteClass {
+            get autocompleteId(): string {
+                return id;
+            }
+        };
+    };
+}
+
+export function condition(id: string) {
+    return <T extends Constructor>(ConditionClass: T): T => {
+        return class extends ConditionClass {
+            get conditionId(): string {
+                return id;
+            }
+        };
+    };
+}
+
+export function trigger(id: string) {
+    return <T extends Constructor>(TriggerClass: T): T => {
+        return class extends TriggerClass {
+            get triggerId(): string {
+                return id;
+            }
+        };
+    };
+}

package/src/flow.ts

@@ -0,0 +1,91 @@
+import type Homey from 'homey';
+import { type App, Shortcuts } from './app';
+import type { AutocompleteProvider, FlowCardType } from './types';
+
+export abstract class FlowEntity<T extends Homey.FlowCard, TArgs = unknown, TState = unknown, TResult = unknown> extends Shortcuts {
+    get card(): T {
+        return this.#card;
+    }
+
+    get id(): string {
+        return this.#card.id;
+    }
+
+    get type(): FlowCardType {
+        return this.#card.type;
+    }
+
+    readonly #card: T;
+
+    constructor(app: App) {
+        super(app);
+
+        this.#card = this.#getCard();
+
+        this.onInit()
+            .then()
+            .catch(console.error.bind(console));
+    }
+
+    async onInit(): Promise<void> {
+        this.#card.registerRunListener(this.onRun.bind(this));
+        this.#card.on('update', this.onUpdate.bind(this));
+
+        this.log(`onInit() -> Flow card ${this.type}#${this.id} has been registered.`);
+    }
+
+    abstract onRun(args: TArgs, state: TState): Promise<TResult>;
+
+    async onUpdate(): Promise<void> {
+    }
+
+    registerAutocomplete<T extends FlowAutocompleteProvider>(name: string, autocompleteProvider: AutocompleteProvider<T>): void {
+        const provider = this.registry.findAutocompleteProvider(autocompleteProvider);
+
+        if (!provider) {
+            throw new Error(`Unable to register autocomplete for ${this.type}#${this.id}. The provider was not registered.`);
+        }
+
+        this.#card.registerArgumentAutocompleteListener(name, provider.find.bind(provider));
+    }
+
+    #getCard(): T {
+        if (this instanceof FlowActionEntity) {
+            return this.homey.flow.getActionCard((this as any).actionId) as unknown as T;
+        }
+
+        if (this instanceof FlowConditionEntity) {
+            return this.homey.flow.getConditionCard((this as any).conditionId) as unknown as T;
+        }
+
+        if (this instanceof FlowTriggerEntity) {
+            return this.homey.flow.getTriggerCard((this as any).triggerId) as unknown as T;
+        }
+
+        throw new Error(`Flow card type ${this.constructor.name} not found.`);
+    }
+}
+
+export abstract class FlowActionEntity<TArgs = unknown, TState = unknown, TResult = unknown> extends FlowEntity<Homey.FlowCardAction, TArgs, TState, TResult> {
+}
+
+export abstract class FlowConditionEntity<TArgs = unknown, TState = unknown> extends FlowEntity<Homey.FlowCardCondition, TArgs, TState, boolean> {
+}
+
+export abstract class FlowTriggerEntity<TArgs = unknown, TState = unknown> extends FlowEntity<Homey.FlowCardTrigger, TArgs, TState, boolean> {
+    async trigger(state: TState, tokens?: Record<string, unknown>): Promise<any> {
+        return this.card.trigger(tokens, state as object);
+    }
+}
+
+export abstract class FlowAutocompleteProvider extends Shortcuts {
+    abstract find(query: string, args: Record<string, unknown>): Promise<Homey.FlowCard.ArgumentAutocompleteResults>;
+
+    async update(): Promise<void> {
+    }
+
+    async onInit(): Promise<void> {
+        this.homey.log(`onInit() -> Autocomplete provider ${(this as any).autocompleteId} has been registered.`);
+        await this.update();
+    }
+}

package/src/index.ts

@@ -0,0 +1,33 @@
+export type {
+    ApiRequest,
+    Color,
+    Constructor,
+    FlowCardType,
+    Icon,
+    Language,
+    WidgetApiRequest
+} from './types';
+
+export {
+    action,
+    autocomplete,
+    condition,
+    trigger
+} from './decorator';
+
+export {
+    FlowEntity,
+    FlowActionEntity,
+    FlowAutocompleteProvider,
+    FlowConditionEntity,
+    FlowTriggerEntity
+} from './flow';
+
+export {
+    Registry
+} from './registry';
+
+export {
+    colors,
+    icons
+} from './data';

package/src/registry.ts

@@ -0,0 +1,58 @@
+import { Shortcuts } from './app';
+import type { FlowActionEntity, FlowAutocompleteProvider, FlowConditionEntity, FlowTriggerEntity } from './flow';
+import type { Action, AutocompleteProvider, Condition, Trigger } from './types';
+
+export class Registry extends Shortcuts {
+    get actions(): FlowActionEntity[] {
+        return this.#actions;
+    }
+
+    get autocompleteProviders(): FlowAutocompleteProvider[] {
+        return this.#autocompleteProviders;
+    }
+
+    get conditions(): FlowConditionEntity[] {
+        return this.#conditions;
+    }
+
+    get triggers(): FlowTriggerEntity[] {
+        return this.#triggers;
+    }
+
+    readonly #actions: FlowActionEntity[] = [];
+    readonly #autocompleteProviders: FlowAutocompleteProvider[] = [];
+    readonly #conditions: FlowConditionEntity[] = [];
+    readonly #triggers: FlowTriggerEntity[] = [];
+
+    action<T extends FlowActionEntity>(action: Action<T>): void {
+        this.#actions.push(new action(this.app));
+    }
+
+    autocompleteProvider<T extends FlowAutocompleteProvider>(autocompleteProvider: AutocompleteProvider<T>): void {
+        this.#autocompleteProviders.push(new autocompleteProvider(this.app));
+    }
+
+    condition<T extends FlowConditionEntity>(condition: Condition<T>): void {
+        this.#conditions.push(new condition(this.app));
+    }
+
+    trigger<T extends FlowTriggerEntity>(trigger: Trigger<T>): void {
+        this.#triggers.push(new trigger(this.app));
+    }
+
+    findAction<T extends FlowActionEntity>(action: Action<T>): T | undefined {
+        return this.#actions.find(a => a instanceof action) as T;
+    }
+
+    findAutocompleteProvider<T extends FlowAutocompleteProvider>(autocompleteProvider: AutocompleteProvider<T>): T | undefined {
+        return this.#autocompleteProviders.find(a => a instanceof autocompleteProvider) as T;
+    }
+
+    findCondition<T extends FlowConditionEntity>(condition: Condition<T>): T | undefined {
+        return this.#conditions.find(a => a instanceof condition) as T;
+    }
+
+    findTrigger<T extends FlowTriggerEntity>(trigger: Trigger<T>): T | undefined {
+        return this.#triggers.find(a => a instanceof trigger) as T;
+    }
+}

package/src/types.ts

@@ -0,0 +1,52 @@
+import type Homey from 'homey/lib/Homey';
+import type { App } from './app';
+import type { FlowActionEntity, FlowAutocompleteProvider, FlowConditionEntity, FlowTriggerEntity } from './flow';
+
+export type Constructor<T = {}> = new (...args: any[]) => T;
+
+export type Action<T extends FlowActionEntity> = new (app: App) => T;
+export type AutocompleteProvider<T extends FlowAutocompleteProvider> = new (app: App) => T;
+export type Condition<T extends FlowConditionEntity> = new (app: App) => T;
+export type Trigger<T extends FlowTriggerEntity> = new (app: App) => T;
+
+export type FlowCardType =
+    | 'action'
+    | 'condition'
+    | 'trigger';
+
+export type Color = {
+    readonly hex: string;
+    readonly label: string;
+};
+
+export type Icon = {
+    readonly id: string;
+    readonly name: string;
+    readonly unicode: string;
+};
+
+export type Language =
+    | 'en'
+    | 'nl'
+    | 'de'
+    | 'es'
+    | 'fr'
+    | 'it'
+    | 'ko'
+    | 'no'
+    | 'pl'
+    | 'ru'
+    | 'sv';
+
+export type ApiRequest<TApp> = {
+    readonly homey: Homey & {
+        readonly app: TApp;
+    };
+    readonly body: any;
+    readonly params: Record<string, unknown>;
+    readonly query: Record<string, string>;
+};
+
+export type WidgetApiRequest<TApp> = ApiRequest<TApp> & {
+    readonly widgetInstanceId: string;
+};

package/tsconfig.json

@@ -0,0 +1,36 @@
+{
+    "compilerOptions": {
+        "target": "esnext",
+        "lib": [
+            "dom",
+            "dom.iterable",
+            "esnext"
+        ],
+        "allowJs": true,
+        "skipLibCheck": true,
+        "strict": false,
+        "forceConsistentCasingInFileNames": true,
+        "esModuleInterop": true,
+        "module": "esnext",
+        "moduleResolution": "bundler",
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "jsx": "react-jsx",
+        "baseUrl": ".",
+        "rootDir": "src",
+        "outDir": "dist",
+        "declaration": true,
+        "declarationDir": "dist",
+        "declarationMap": true,
+        "emitDeclarationOnly": true,
+        "experimentalDecorators": true
+    },
+    "include": [
+        "src/**/*.ts",
+        "build.ts"
+    ],
+    "exclude": [
+        "dist",
+        "node_modules"
+    ]
+}