mnfst 0.5.18 → 0.5.20

package/dist/manifest.appwrite.auth.js

@@ -966,6 +966,45 @@ function initializeAuthMagic() {
                     if (typeof value === 'function') {
                         return value.bind(store);
                     }
+                    // CRITICAL: If property exists but is not a function, check if it should be a convenience method
+                    // This handles cases where the store was recreated and methods are missing
+                    if (typeof prop === 'string') {
+                        const convenienceMethodNames = [
+                            'isCreatingTeam', 'isUpdatingTeam', 'isDeletingTeam', 'isInvitingMember',
+                            'isUpdatingMember', 'isDeletingMember', 'createTeamFromName', 'updateCurrentTeamName',
+                            'inviteToCurrentTeam', 'viewTeam', 'isCurrentTeamOwner', 'isTeamDeletable',
+                            'isTeamRenamable', 'hasTeamPermission', 'hasTeamPermissionSync', 'canManageRoles',
+                            'canInviteMembers', 'canUpdateMembers', 'canRemoveMembers', 'canRenameTeam',
+                            'canDeleteTeam', 'isRoleDeletable', 'isRoleBeingEdited', 'getCurrentTeamRoles',
+                            'getUserRole', 'getUserRoles', 'getAllAvailablePermissions'
+                        ];
+                        
+                        if (convenienceMethodNames.includes(prop)) {
+                            // This should be a function but isn't - try to reinitialize synchronously
+                            if (window.ManifestAppwriteAuthTeamsConvenience && window.ManifestAppwriteAuthTeamsConvenience.initialize) {
+                                try {
+                                    // Call initialize which will check and re-add methods if needed
+                                    window.ManifestAppwriteAuthTeamsConvenience.initialize();
+                                    // Immediately check again - initialize should have added the method
+                                    const reinitializedValue = store[prop];
+                                    if (typeof reinitializedValue === 'function') {
+                                        return reinitializedValue.bind(store);
+                                    }
+                                } catch (error) {
+                                    // Failed to reinitialize, continue to fallback
+                                }
+                            }
+                            // Return a safe fallback function that returns false/empty
+                            // This prevents "is not a function" errors while methods are being reinitialized
+                            if (prop.startsWith('is') || prop.startsWith('can') || prop.startsWith('has')) {
+                                return () => false;
+                            }
+                            if (prop.startsWith('get')) {
+                                return () => null;
+                            }
+                            return () => ({ success: false, error: 'Method not initialized' });
+                        }
+                    }
                     // CRITICAL: Handle null values - return loading proxy to allow safe chaining
                     // This prevents errors when accessing $auth.user.email when user is null
                     if (value === null || value === undefined) {
@@ -4495,6 +4534,10 @@ function initializeTeamsConvenience() {
     const waitForStore = () => {
         const store = Alpine.store('auth');
         if (store) {
+            // CRITICAL: Check if convenience methods exist - use isCreatingTeam as the key check
+            // This ensures methods are re-added if the store was replaced or methods were lost after idle
+            const needsReinitialization = !store.isCreatingTeam || typeof store.isCreatingTeam !== 'function';
+            
             // Ensure cache properties are initialized (methods are already in store)
             if (!store._permissionCache) store._permissionCache = {};
             if (store._userRoleCache === undefined) store._userRoleCache = null;
@@ -4576,7 +4619,7 @@ function initializeTeamsConvenience() {
 
             // CRITICAL: Check if convenience methods exist - use isCreatingTeam as the key check
             // This ensures methods are re-added if the store was replaced or methods were lost after idle
-            if (!store.isCreatingTeam || typeof store.isCreatingTeam !== 'function') {
+            if (needsReinitialization) {
                 // Convenience method: create team using newTeamName property
                 store.createTeamFromName = async function () {
                     // Ensure newTeamName is a string and has content

package/dist/manifest.components.js

@@ -350,6 +350,19 @@ window.ManifestComponentsProcessor = {
         // magic methods are available. This prevents "i is not a function" errors.
         if (window.Alpine && typeof window.Alpine.initTree === 'function') {
             const initAlpine = () => {
+                // CRITICAL: Ensure auth convenience methods are initialized before Alpine evaluates expressions
+                // This prevents "$auth.isCreatingTeam is not a function" errors after idle/reinitialization
+                if (window.ManifestAppwriteAuthTeamsConvenience && window.ManifestAppwriteAuthTeamsConvenience.initialize) {
+                    try {
+                        const authStore = window.Alpine.store('auth');
+                        if (authStore && (!authStore.isCreatingTeam || typeof authStore.isCreatingTeam !== 'function')) {
+                            window.ManifestAppwriteAuthTeamsConvenience.initialize();
+                        }
+                    } catch (error) {
+                        // Failed to reinitialize, continue anyway
+                    }
+                }
+
                 // Re-initialize Alpine on the swapped elements
                 // This ensures magic methods are available when expressions are evaluated
                 topLevelElements.forEach(el => {
@@ -703,22 +716,14 @@ function initializeComponents() {
     window.dispatchEvent(new CustomEvent('manifest:components-ready'));
 }
 
-// Wait for data plugin to be ready before initializing components
-// This ensures $x magic method is available when components are processed
+// Wait for data plugin to be ready (including content pre-load) before initializing components
+// manifest:data-ready fires after critical data sources are loaded, so $x.content is ready when components render
 function waitForDataThenInitialize() {
-    // Check if data plugin is already ready
-    if (window.__manifestDataMagicRegistered) {
-        initializeComponents();
-        return;
-    }
-
-    // Wait for data-ready event
     window.addEventListener('manifest:data-ready', () => {
         initializeComponents();
     }, { once: true });
 
     // Fallback: if data plugin doesn't fire event within reasonable time, initialize anyway
-    // This handles cases where data plugin isn't loaded or doesn't use magic methods
     setTimeout(() => {
         if (!window.__manifestComponentsInitialized) {
             initializeComponents();