@timothyw/pat-common 1.0.121 → 1.0.123

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './enums';
 export * from './types';
 export * from './utils';
+export * from './notification-entity-registry';

package/dist/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./enums"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./notification-entity-registry"), exports);

package/dist/notification-entity-registry.d.ts

@@ -0,0 +1,77 @@
+import { NotificationEntityConfig, ParentResolutionResult } from './types/notification-entity-config';
+/**
+ * Registry for managing notification entity configurations and parent resolution
+ */
+export declare class NotificationEntityRegistry {
+    private static instance;
+    private entityConfigs;
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static getInstance(): NotificationEntityRegistry;
+    /**
+     * Register a new entity configuration
+     */
+    registerEntity(config: NotificationEntityConfig): void;
+    /**
+     * Get configuration for an entity type
+     */
+    getEntityConfig(entityType: string): NotificationEntityConfig | null;
+    /**
+     * Get all registered entity types
+     */
+    getEntityTypes(): string[];
+    /**
+     * Get all entity configurations
+     */
+    getAllConfigs(): NotificationEntityConfig[];
+    /**
+     * Resolve the parent type for a specific entity instance
+     */
+    resolveParent(entityType: string, entityData: any): ParentResolutionResult | null;
+    /**
+     * Check if an entity type supports dynamic parent resolution
+     */
+    isDynamicParentType(entityType: string): boolean;
+    /**
+     * Get the parent property name for dynamic resolution
+     */
+    getParentProperty(entityType: string): string | null;
+    /**
+     * Get display name for an entity type
+     */
+    getDisplayName(entityType: string): string;
+    /**
+     * Get icon for an entity type
+     */
+    getIcon(entityType: string): string | null;
+    /**
+     * Check if entity type exists
+     */
+    hasEntityType(entityType: string): boolean;
+    /**
+     * Remove an entity configuration
+     */
+    unregisterEntity(entityType: string): boolean;
+    /**
+     * Clear all configurations
+     */
+    clear(): void;
+    /**
+     * Resolve static parent type
+     */
+    private resolveStaticParent;
+    /**
+     * Resolve dynamic parent type based on entity data
+     */
+    private resolveDynamicParent;
+    /**
+     * Register default entity configurations
+     */
+    private registerDefaultEntities;
+}
+/**
+ * Convenience function to get the singleton instance
+ */
+export declare function getNotificationEntityRegistry(): NotificationEntityRegistry;

package/dist/notification-entity-registry.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationEntityRegistry = void 0;
+exports.getNotificationEntityRegistry = getNotificationEntityRegistry;
+/**
+ * Registry for managing notification entity configurations and parent resolution
+ */
+class NotificationEntityRegistry {
+    constructor() {
+        this.entityConfigs = new Map();
+        // Initialize with default configurations
+        this.registerDefaultEntities();
+    }
+    /**
+     * Get the singleton instance
+     */
+    static getInstance() {
+        if (!NotificationEntityRegistry.instance) {
+            NotificationEntityRegistry.instance = new NotificationEntityRegistry();
+        }
+        return NotificationEntityRegistry.instance;
+    }
+    /**
+     * Register a new entity configuration
+     */
+    registerEntity(config) {
+        this.entityConfigs.set(config.entityType, config);
+    }
+    /**
+     * Get configuration for an entity type
+     */
+    getEntityConfig(entityType) {
+        return this.entityConfigs.get(entityType) || null;
+    }
+    /**
+     * Get all registered entity types
+     */
+    getEntityTypes() {
+        return Array.from(this.entityConfigs.keys());
+    }
+    /**
+     * Get all entity configurations
+     */
+    getAllConfigs() {
+        return Array.from(this.entityConfigs.values());
+    }
+    /**
+     * Resolve the parent type for a specific entity instance
+     */
+    resolveParent(entityType, entityData) {
+        const config = this.entityConfigs.get(entityType);
+        if (!config) {
+            return null;
+        }
+        const resolver = config.parentResolver;
+        if (resolver.type === 'static') {
+            return this.resolveStaticParent(resolver);
+        }
+        else {
+            return this.resolveDynamicParent(resolver, entityData);
+        }
+    }
+    /**
+     * Check if an entity type supports dynamic parent resolution
+     */
+    isDynamicParentType(entityType) {
+        const config = this.entityConfigs.get(entityType);
+        return config?.parentResolver.type === 'dynamic' || false;
+    }
+    /**
+     * Get the parent property name for dynamic resolution
+     */
+    getParentProperty(entityType) {
+        const config = this.entityConfigs.get(entityType);
+        if (config?.parentResolver.type === 'dynamic') {
+            return config.parentResolver.parentProperty;
+        }
+        return null;
+    }
+    /**
+     * Get display name for an entity type
+     */
+    getDisplayName(entityType) {
+        const config = this.entityConfigs.get(entityType);
+        return config?.displayName || entityType;
+    }
+    /**
+     * Get icon for an entity type
+     */
+    getIcon(entityType) {
+        const config = this.entityConfigs.get(entityType);
+        return config?.icon || null;
+    }
+    /**
+     * Check if entity type exists
+     */
+    hasEntityType(entityType) {
+        return this.entityConfigs.has(entityType);
+    }
+    /**
+     * Remove an entity configuration
+     */
+    unregisterEntity(entityType) {
+        return this.entityConfigs.delete(entityType);
+    }
+    /**
+     * Clear all configurations
+     */
+    clear() {
+        this.entityConfigs.clear();
+    }
+    /**
+     * Resolve static parent type
+     */
+    resolveStaticParent(resolver) {
+        return {
+            parentType: resolver.parentType,
+            isDynamic: false
+        };
+    }
+    /**
+     * Resolve dynamic parent type based on entity data
+     */
+    resolveDynamicParent(resolver, entityData) {
+        const propertyValue = entityData?.[resolver.parentProperty];
+        if (propertyValue && typeof propertyValue === 'string' && propertyValue.trim()) {
+            // Use the property value to construct the parent type
+            const parentType = resolver.parentTypePrefix + propertyValue.trim();
+            return {
+                parentType,
+                isDynamic: true,
+                resolvedProperty: propertyValue.trim(),
+                usedFallback: false
+            };
+        }
+        // Fall back to default parent
+        return {
+            parentType: resolver.fallbackParent,
+            isDynamic: true,
+            usedFallback: true
+        };
+    }
+    /**
+     * Register default entity configurations
+     */
+    registerDefaultEntities() {
+        // Agenda Panel (dynamic parent for agenda items based on category)
+        this.registerEntity({
+            entityType: 'agenda_panel',
+            parentResolver: {
+                type: 'static',
+                parentType: 'agenda_panel' // Panel level templates
+            },
+            displayName: 'Agenda Panel',
+            icon: 'calendar',
+            description: 'Default agenda panel templates'
+        });
+        // Agenda Item (dynamic parent based on category)
+        this.registerEntity({
+            entityType: 'agenda_item',
+            parentResolver: {
+                type: 'dynamic',
+                parentProperty: 'category',
+                parentTypePrefix: 'agenda_category_',
+                fallbackParent: 'agenda_panel'
+            },
+            displayName: 'Agenda Item',
+            icon: 'calendar',
+            description: 'Individual agenda item notifications'
+        });
+        // Habits Panel (static parent for habits)
+        this.registerEntity({
+            entityType: 'habits_panel',
+            parentResolver: {
+                type: 'static',
+                parentType: 'habits_panel'
+            },
+            displayName: 'Habits Panel',
+            icon: 'fitness',
+            description: 'Default habits panel templates'
+        });
+        // Habit (static parent - all habits inherit from habits panel)
+        this.registerEntity({
+            entityType: 'habit',
+            parentResolver: {
+                type: 'static',
+                parentType: 'habits_panel'
+            },
+            displayName: 'Habit',
+            icon: 'fitness',
+            description: 'Individual habit notifications'
+        });
+        // Inbox Panel (no parent - top level)
+        this.registerEntity({
+            entityType: 'inbox_panel',
+            parentResolver: {
+                type: 'static',
+                parentType: '' // No parent - this is a top-level entity
+            },
+            displayName: 'Inbox Panel',
+            icon: 'mail',
+            description: 'Inbox notifications'
+        });
+    }
+}
+exports.NotificationEntityRegistry = NotificationEntityRegistry;
+/**
+ * Convenience function to get the singleton instance
+ */
+function getNotificationEntityRegistry() {
+    return NotificationEntityRegistry.getInstance();
+}

package/dist/types/index.d.ts

@@ -6,7 +6,7 @@ export * from './id-types';
 export * from './people-types';
 export * from './lists-types';
 export * from './notifications-types';
+export * from './notification-entity-config';
 export * from './auth-types';
 export * from './user-types';
 export * from './program-config-types';
-export * from './misc';

package/dist/types/index.js

@@ -22,7 +22,7 @@ __exportStar(require("./id-types"), exports);
 __exportStar(require("./people-types"), exports);
 __exportStar(require("./lists-types"), exports);
 __exportStar(require("./notifications-types"), exports);
+__exportStar(require("./notification-entity-config"), exports);
 __exportStar(require("./auth-types"), exports);
 __exportStar(require("./user-types"), exports);
 __exportStar(require("./program-config-types"), exports);
-__exportStar(require("./misc"), exports);

package/dist/types/notification-entity-config.d.ts

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+/**
+ * Static parent resolver - entity always inherits from the same parent type
+ */
+export interface StaticParentResolver {
+    type: 'static';
+    parentType: string;
+}
+/**
+ * Dynamic parent resolver - parent determined by entity properties
+ */
+export interface DynamicParentResolver {
+    type: 'dynamic';
+    parentProperty: string;
+    parentTypePrefix: string;
+    fallbackParent: string;
+}
+export type ParentResolver = StaticParentResolver | DynamicParentResolver;
+/**
+ * Configuration for a notification entity type
+ */
+export interface NotificationEntityConfig {
+    entityType: string;
+    parentResolver: ParentResolver;
+    displayName: string;
+    icon?: string;
+    description?: string;
+}
+/**
+ * Result of parent resolution for a specific entity instance
+ */
+export interface ParentResolutionResult {
+    parentType: string;
+    isDynamic: boolean;
+    resolvedProperty?: string;
+    usedFallback?: boolean;
+}
+/**
+ * Zod schemas for validation
+ */
+export declare const staticParentResolverSchema: z.ZodObject<{
+    type: z.ZodLiteral<"static">;
+    parentType: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "static";
+    parentType: string;
+}, {
+    type: "static";
+    parentType: string;
+}>;
+export declare const dynamicParentResolverSchema: z.ZodObject<{
+    type: z.ZodLiteral<"dynamic">;
+    parentProperty: z.ZodString;
+    parentTypePrefix: z.ZodString;
+    fallbackParent: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "dynamic";
+    parentProperty: string;
+    parentTypePrefix: string;
+    fallbackParent: string;
+}, {
+    type: "dynamic";
+    parentProperty: string;
+    parentTypePrefix: string;
+    fallbackParent: string;
+}>;
+export declare const parentResolverSchema: z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"static">;
+    parentType: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "static";
+    parentType: string;
+}, {
+    type: "static";
+    parentType: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"dynamic">;
+    parentProperty: z.ZodString;
+    parentTypePrefix: z.ZodString;
+    fallbackParent: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "dynamic";
+    parentProperty: string;
+    parentTypePrefix: string;
+    fallbackParent: string;
+}, {
+    type: "dynamic";
+    parentProperty: string;
+    parentTypePrefix: string;
+    fallbackParent: string;
+}>]>;
+export declare const notificationEntityConfigSchema: z.ZodObject<{
+    entityType: z.ZodString;
+    parentResolver: z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"static">;
+        parentType: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "static";
+        parentType: string;
+    }, {
+        type: "static";
+        parentType: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"dynamic">;
+        parentProperty: z.ZodString;
+        parentTypePrefix: z.ZodString;
+        fallbackParent: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "dynamic";
+        parentProperty: string;
+        parentTypePrefix: string;
+        fallbackParent: string;
+    }, {
+        type: "dynamic";
+        parentProperty: string;
+        parentTypePrefix: string;
+        fallbackParent: string;
+    }>]>;
+    displayName: z.ZodString;
+    icon: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    entityType: string;
+    parentResolver: {
+        type: "static";
+        parentType: string;
+    } | {
+        type: "dynamic";
+        parentProperty: string;
+        parentTypePrefix: string;
+        fallbackParent: string;
+    };
+    displayName: string;
+    description?: string | undefined;
+    icon?: string | undefined;
+}, {
+    entityType: string;
+    parentResolver: {
+        type: "static";
+        parentType: string;
+    } | {
+        type: "dynamic";
+        parentProperty: string;
+        parentTypePrefix: string;
+        fallbackParent: string;
+    };
+    displayName: string;
+    description?: string | undefined;
+    icon?: string | undefined;
+}>;
+/**
+ * Type exports
+ */
+export type StaticParentResolverData = z.infer<typeof staticParentResolverSchema>;
+export type DynamicParentResolverData = z.infer<typeof dynamicParentResolverSchema>;
+export type ParentResolverData = z.infer<typeof parentResolverSchema>;
+export type NotificationEntityConfigData = z.infer<typeof notificationEntityConfigSchema>;

package/dist/types/notification-entity-config.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notificationEntityConfigSchema = exports.parentResolverSchema = exports.dynamicParentResolverSchema = exports.staticParentResolverSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Zod schemas for validation
+ */
+exports.staticParentResolverSchema = zod_1.z.object({
+    type: zod_1.z.literal('static'),
+    parentType: zod_1.z.string()
+});
+exports.dynamicParentResolverSchema = zod_1.z.object({
+    type: zod_1.z.literal('dynamic'),
+    parentProperty: zod_1.z.string(),
+    parentTypePrefix: zod_1.z.string(),
+    fallbackParent: zod_1.z.string()
+});
+exports.parentResolverSchema = zod_1.z.union([
+    exports.staticParentResolverSchema,
+    exports.dynamicParentResolverSchema
+]);
+exports.notificationEntityConfigSchema = zod_1.z.object({
+    entityType: zod_1.z.string(),
+    parentResolver: exports.parentResolverSchema,
+    displayName: zod_1.z.string(),
+    icon: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional()
+});