@dashadmin/dash-app-common 1.3.24 → 1.3.26

package/src/defaults/extensions/utils/dashDefaultAuthProviderUtils.ts

@@ -0,0 +1,36 @@
+/**
+ * Dash Default Auth Provider Utilities
+ * 
+ * Dash default authentication utilities.
+ * Uses the base utilities from dash-utils with default configuration.
+ */
+import { AuthPersistenceService, syncLocalStorageToDeviceStore } from 'dash-auth';
+import { 
+    createLogoutFromStorage,
+    isUserAuthenticated,
+    getCurrentUser,
+    getAuthToken
+} from 'dash-utils';
+import { removeCookie } from 'dash-admin/src/utils/cookies';
+
+/**
+ * Dash default logout function
+ * Configured with AuthPersistenceService and cookie removal
+ */
+export const dashDefaultLogoutFromStorage = createLogoutFromStorage({
+    clearAuthPersistence: () => AuthPersistenceService.clearAuth(),
+    syncToDeviceStore: syncLocalStorageToDeviceStore,
+    removeCookies: (names) => names.forEach(name => removeCookie(name))
+});
+
+// Re-export utility functions from dash-utils with DashDefault prefix
+export const dashDefaultIsAuthenticated = isUserAuthenticated;
+export const dashDefaultGetCurrentUser = getCurrentUser;
+export const dashDefaultGetToken = getAuthToken;
+
+export default {
+    dashDefaultLogoutFromStorage,
+    dashDefaultIsAuthenticated,
+    dashDefaultGetCurrentUser,
+    dashDefaultGetToken
+};

package/src/defaults/extensions/utils/dashDefaultDataProviderUtils.ts

@@ -0,0 +1,46 @@
+/**
+ * Dash Default Data Provider Utilities
+ * 
+ * Dash default data provider utilities.
+ * Re-exports from dash-utils with default types.
+ */
+import { IDashAutoAdminResourceConfig } from 'dash-auto-admin';
+import {
+    setResourceConfigs as setConfigs,
+    getResourceConfig as getConfig,
+    processPostData as processData,
+    processFormData,
+    buildQueryString,
+    isFormDataResource
+} from 'dash-utils';
+
+// Type-safe wrappers for the app's resource config type
+export const dashDefaultSetResourceConfigs = (configs: IDashAutoAdminResourceConfig[]): void => {
+    setConfigs(configs as any);
+};
+
+export const dashDefaultGetResourceConfig = (resource: string): IDashAutoAdminResourceConfig | undefined => {
+    return getConfig(resource) as IDashAutoAdminResourceConfig | undefined;
+};
+
+export const dashDefaultProcessPostData = (
+    resource: string,
+    data: Record<string, any>,
+    operation: 'create' | 'update' | 'getList' | 'import'
+): Record<string, any> => {
+    return processData(resource, data, operation);
+};
+
+// Re-export other utilities with DashDefault prefix
+export const dashDefaultProcessFormData = processFormData;
+export const dashDefaultBuildQueryString = buildQueryString;
+export const dashDefaultIsFormDataResource = isFormDataResource;
+
+export default {
+    dashDefaultGetResourceConfig,
+    dashDefaultSetResourceConfigs,
+    dashDefaultProcessPostData,
+    dashDefaultProcessFormData,
+    dashDefaultBuildQueryString,
+    dashDefaultIsFormDataResource
+};

package/src/defaults/extensions/utils/dashDefaultNotificationsProcessor.tsx

@@ -0,0 +1,208 @@
+/**
+ * Dash Default Notifications Processor
+ * 
+ * Dash default notification processing utilities.
+ */
+
+// Audio context for better browser compatibility
+let audioContext: AudioContext | null = null;
+
+// Re-export from dash-utils for backward compatibility
+export { requestNotificationPermission as requestDashDefaultNotificationPermission } from 'dash-utils';
+
+// Digital watch alarm configuration
+const ALARM_DURATION_SECONDS = 10;
+const ALARM_FREQUENCY_HIGH = 4000; // High frequency like digital watch
+const ALARM_FREQUENCY_LOW = 2500;  // Alternating low frequency
+const BEEP_DURATION_MS = 100;      // Short beeps
+const BEEP_GAP_MS = 50;            // Gap between beeps
+const BEEP_PATTERN_GAP_MS = 300;   // Gap between beep patterns
+
+const initializeAudio = async (): Promise<boolean> => {
+    try {
+        // Initialize AudioContext if not already done
+        if (!audioContext) {
+            audioContext = new (window.AudioContext || (window as any).webkitAudioContext)();
+        }
+
+        // Resume audio context if suspended (required by some browsers)
+        if (audioContext.state === 'suspended') {
+            await audioContext.resume();
+        }
+
+        return true;
+    } catch (error) {
+        console.error('Failed to initialize audio context:', error);
+        return false;
+    }
+};
+
+/**
+ * Play a single beep at specified frequency using oscillator (more reliable than buffer)
+ */
+const playOscillatorBeep = (frequency: number, durationMs: number): Promise<void> => {
+    return new Promise((resolve) => {
+        if (!audioContext) {
+            resolve();
+            return;
+        }
+
+        try {
+            const oscillator = audioContext.createOscillator();
+            const gainNode = audioContext.createGain();
+
+            oscillator.connect(gainNode);
+            gainNode.connect(audioContext.destination);
+
+            oscillator.type = 'square'; // Square wave for that classic digital watch sound
+            oscillator.frequency.setValueAtTime(frequency, audioContext.currentTime);
+
+            // Quick attack, sustain, quick release for sharp beep
+            const now = audioContext.currentTime;
+            gainNode.gain.setValueAtTime(0, now);
+            gainNode.gain.linearRampToValueAtTime(0.4, now + 0.005); // 5ms attack
+            gainNode.gain.setValueAtTime(0.4, now + (durationMs / 1000) - 0.01);
+            gainNode.gain.linearRampToValueAtTime(0, now + (durationMs / 1000)); // 10ms release
+
+            oscillator.start(now);
+            oscillator.stop(now + (durationMs / 1000));
+
+            oscillator.onended = () => resolve();
+        } catch (error) {
+            console.error('Failed to play oscillator beep:', error);
+            resolve();
+        }
+    });
+};
+
+/**
+ * Play a digital watch alarm pattern: beep-beep-beep (pause) beep-beep-beep
+ * Alternates between high and low frequencies
+ */
+const playAlarmPattern = async (useHighFreq: boolean): Promise<void> => {
+    const freq = useHighFreq ? ALARM_FREQUENCY_HIGH : ALARM_FREQUENCY_LOW;
+    
+    // Play 3 quick beeps
+    for (let i = 0; i < 3; i++) {
+        await playOscillatorBeep(freq, BEEP_DURATION_MS);
+        if (i < 2) {
+            await new Promise(r => setTimeout(r, BEEP_GAP_MS));
+        }
+    }
+};
+
+/**
+ * Play the full digital watch alarm sequence for specified duration
+ * Returns a Promise that resolves when alarm completes
+ * @param durationSeconds - Duration in seconds (default: 10)
+ * @param settings - Optional alarm settings to override defaults
+ */
+export interface AlarmSettings {
+    alarmDurationSeconds?: number;
+    alarmFrequencyHigh?: number;
+    alarmFrequencyLow?: number;
+    beepDurationMs?: number;
+    beepGapMs?: number;
+    beepPatternGapMs?: number;
+}
+
+export const playDashDefaultDigitalWatchAlarm = async (
+    durationSeconds?: number,
+    settings?: AlarmSettings
+): Promise<void> => {
+    // Use provided settings or defaults
+    const duration = durationSeconds ?? settings?.alarmDurationSeconds ?? ALARM_DURATION_SECONDS;
+    const frequencyHigh = settings?.alarmFrequencyHigh ?? ALARM_FREQUENCY_HIGH;
+    const frequencyLow = settings?.alarmFrequencyLow ?? ALARM_FREQUENCY_LOW;
+    const beepDuration = settings?.beepDurationMs ?? BEEP_DURATION_MS;
+    const beepGap = settings?.beepGapMs ?? BEEP_GAP_MS;
+    const patternGap = settings?.beepPatternGapMs ?? BEEP_PATTERN_GAP_MS;
+    
+    console.log(`🔔 Starting digital watch alarm for ${duration} seconds...`);
+    
+    const initialized = await initializeAudio();
+    if (!initialized) {
+        console.error('Failed to initialize audio for alarm');
+        return;
+    }
+
+    const startTime = Date.now();
+    const endTime = startTime + (duration * 1000);
+    let patternCount = 0;
+
+    // Custom playAlarmPattern that uses provided settings
+    const playPatternWithSettings = async (useHighFreq: boolean): Promise<void> => {
+        const freq = useHighFreq ? frequencyHigh : frequencyLow;
+        
+        // Play 3 quick beeps
+        for (let i = 0; i < 3; i++) {
+            await playOscillatorBeep(freq, beepDuration);
+            if (i < 2 && beepGap > 0) {
+                await new Promise(r => setTimeout(r, beepGap));
+            }
+        }
+    };
+
+    while (Date.now() < endTime) {
+        // Alternate between high and low frequency patterns
+        const useHighFreq = patternCount % 2 === 0;
+        await playPatternWithSettings(useHighFreq);
+        
+        patternCount++;
+        
+        // Check if we still have time for another pattern
+        if (Date.now() < endTime && patternGap > 0) {
+            await new Promise(r => setTimeout(r, patternGap));
+        }
+    }
+
+    console.log(`🔔 Digital watch alarm completed (${patternCount} patterns played)`);
+};
+
+/**
+ * Legacy single beep for backwards compatibility
+ */
+export const playDashDefaultNotificationSound = async (): Promise<void> => {
+    await playOscillatorBeep(ALARM_FREQUENCY_HIGH, BEEP_DURATION_MS);
+};
+
+export const processDashDefaultNotification = async (notification: any): Promise<{ alarmCompleted: boolean }> => {
+
+    let marketplace = notification?.data?.marketplace?.system_marketplace?.name || "STORE" ;
+    const isConfirmedStatus = notification?.data?.new === "CONFIRMED";
+    let play = false;
+
+    // Play alarm sound, if notification is assistance request or order is confirmed. 
+
+    if (notification?.notificationPayload?.class === "MallStoreAssistanceNotification") {
+        play = true;
+      
+    }
+
+    if (isConfirmedStatus) {
+        play = true;
+    }
+
+    if (play) {
+      
+        console.log("🚨 Playing digital watch alarm for new order...");
+        
+        // Play the digital watch alarm for 10 seconds
+        // This returns a Promise that resolves when alarm is complete
+        await playDashDefaultDigitalWatchAlarm(ALARM_DURATION_SECONDS);
+        
+        console.log("✅ Alarm sequence completed - TTS can now play");
+      
+        // Also show a browser notification if permissions allow
+        if ('Notification' in window && Notification.permission === 'granted') {
+            new Notification(`Nueva Orden de ${marketplace}`, {
+                body: notification?.data?.message || 'Nueva orden recibida',
+                icon: 'https://cdn.jsdelivr.net/gh/twitter/twemoji@14.0.2/assets/72x72/1f6a8.png', // Alarm icon emoji
+            });
+        }
+        
+        return { alarmCompleted: true };
+    }
+    
+    return { alarmCompleted: false };
+};

package/src/defaults/extensions/utils/index.ts

@@ -0,0 +1,42 @@
+/**
+ * Utils Extensions Index
+ * 
+ * Utility functions and contexts.
+ */
+
+// Auth Provider Utils
+export { 
+    dashDefaultLogoutFromStorage, 
+    dashDefaultIsAuthenticated, 
+    dashDefaultGetCurrentUser, 
+    dashDefaultGetToken 
+} from './dashDefaultAuthProviderUtils';
+
+// Data Provider Utils
+export { 
+    dashDefaultGetResourceConfig, 
+    dashDefaultSetResourceConfigs, 
+    dashDefaultProcessPostData, 
+    dashDefaultProcessFormData, 
+    dashDefaultBuildQueryString, 
+    dashDefaultIsFormDataResource 
+} from './dashDefaultDataProviderUtils';
+
+// IPC Message Broker
+export {
+    DashIPCMessageBrokerContext,
+    DashIPCMessageBrokerProvider,
+    useDashIPCMessageBroker,
+    type DashLogMessage,
+    type DashSubprocessOutput,
+    type DashIPCMessageBrokerContextType,
+    type DashIPCMessageBrokerConfig
+} from './IPCMessageBrokerContext';
+
+// Notifications Processor
+export { 
+    processDashDefaultNotification, 
+    playDashDefaultNotificationSound, 
+    playDashDefaultDigitalWatchAlarm,
+    requestDashDefaultNotificationPermission 
+} from './dashDefaultNotificationsProcessor';

package/src/defaults/filters/demo/dashDefaultDemoFilters.tsx

@@ -0,0 +1,50 @@
+/**
+ * Dash Default Demo Filters
+ * 
+ * Example filter configurations for demonstration purposes.
+ * These filters showcase different filter types and configurations.
+ */
+import React from "react";
+import { SelectInput } from "react-admin";
+import IReferenceFilter from "dash-auto-admin/src/interfaces/IReferenceFilter";
+
+/**
+ * Dash default demo filters for resource lists
+ * 
+ * Demonstrates:
+ * - Text filters (name, description)
+ * - Select filters with static options (status)
+ */
+const dashDefaultDemoFilters: IReferenceFilter[] = [
+    {
+        id: 'name',
+        label: 'Name',
+        source: 'name',
+        alwaysOn: true,
+        reference: null,
+        optionText: null,
+    },
+    {
+        id: 'description',
+        label: 'Description',
+        source: 'description',
+        alwaysOn: true,
+        reference: null,
+        optionText: null,
+    },
+    {
+        id: 'status',
+        label: 'Status',
+        source: 'status',
+        reference: [
+            { id: 'active', name: 'Active' },
+            { id: 'inactive', name: 'Inactive' },
+            { id: 'pending', name: 'Pending' },
+        ],
+        optionText: 'status',
+        alwaysOn: true,
+        referenceComponent: SelectInput,
+    }
+];
+
+export default dashDefaultDemoFilters;

package/src/defaults/filters/demo/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Demo Filters Module
+ * 
+ * Exports demo filter configurations.
+ */
+export { default as dashDefaultDemoFilters } from './dashDefaultDemoFilters';

package/src/defaults/filters/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Default Filters Index
+ * 
+ * Default filter configurations for resource lists.
+ * These filters provide common filtering patterns that can be
+ * customized or extended for specific resources.
+ */
+
+// Demo filters
+export * from './demo';
+export { default as dashDefaultDemoFilters } from './demo/dashDefaultDemoFilters';

package/src/defaults/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Defaults Index
+ * 
+ * Exports all default components, routes, extensions, pages, filters, and schemas
+ * for the dash-app-common package. This provides a complete zero-config solution
+ * that can be customized or extended by applications.
+ */
+
+// Default routes (from extensions/router)
+export { dashDefaultPublicRoutes as defaultPublicRoutes } from './extensions/router/dashDefaultPublicRoutes';
+export { dashDefaultPrivateRoutes as defaultPrivateRoutes } from './extensions/router/dashDefaultPrivateRoutes';
+
+// Default app components
+export { default as DashDefaultPublicApp } from '../components/DashDefaultPublicApp';
+export { default as DashDefaultPrivateApp } from '../components/DashDefaultPrivateApp';
+
+// Extensions
+export * from './extensions';
+
+// Pages
+export * from './pages';
+
+// Filters
+export * from './filters';
+
+// Schemas
+export * from './schemas';