ultimate-jekyll-manager 0.0.60 → 0.0.62

package/.claude/settings.local.json

@@ -34,7 +34,13 @@
       "Read(/Users/ian/Developer/Repositories/ITW-Creative-Works/jekyll-uj-powertools/**)",
       "Read(/Users/ian/Developer/Repositories/ITW-Creative-Works/jekyll-uj-powertools/**)",
       "Read(/Users/ian/Developer/Repositories/ITW-Creative-Works/jekyll-uj-powertools/**)",
-      "Read(/Users/ian/Developer/Repositories/ITW-Creative-Works/jekyll-uj-powertools/**)"
+      "Read(/Users/ian/Developer/Repositories/ITW-Creative-Works/jekyll-uj-powertools/**)",
+      "Bash(for:*)",
+      "Bash(do if [[ \"$file\" != *\"-\"* ]])",
+      "Bash(then [ -f \"$file\" ])",
+      "Bash(fi)",
+      "Bash(done)",
+      "Bash(do [ -f \"$file\" ])"
     ],
     "deny": []
   }

package/_notes/NOTES-app.md

@@ -0,0 +1,92 @@
+{
+  "server": "https://us-central1-studymonkey-ai.cloudfunctions.net",
+  "images": {
+    "combomark": "https://cdn.itwcreativeworks.com/assets/studymonkey/images/logo/studymonkey-combomark-black-1024x.png",
+    "brandmark": "https://cdn.itwcreativeworks.com/assets/studymonkey/images/logo/studymonkey-brandmark-black-1024x1024.png",
+    "wordmark": "https://cdn.itwcreativeworks.com/assets/studymonkey/images/logo/studymonkey-wordmark-black-1024x.png"
+  },
+  "github": {
+    "repo": "studymonkey-website",
+    "user": "ianwieds"
+  },
+  "apiKeys": {
+    "stripe": {
+      "publishableKey": "pk_live_51Mirn8HGybgi7uQGuE5IcaED0VByYRfVXGUmBDqnUyldcf2BJrpiFCDmwu4NoSDv34LMBw5mfCNdB3pmRki0jhmx00jFgW4akz"
+    },
+    "chatsy": {
+      "accountId": "EG6j4wzyykSrHluANgIVTvyjzyu1",
+      "chatId": "LP8IKB0sRjARSO"
+    },
+    "paypal": {
+      "clientId": "AQSXMAqVuJYriyKEpaEc9xhS4hkm7iSlLjNRXSBdkM234figh599SMQbc0VMfYrm2Vh74J3u4jdeFYH9"
+    },
+    "chargebee": {
+      "siteKey": ""
+    }
+  },
+  "oauth2": {
+    "discord": {
+      "scope": ["identify", "guilds", "guilds.join"],
+      "enabled": true
+    },
+    "google": {
+      "enabled": false
+    }
+  },
+  "url": "https://studymonkey.ai",
+  "products": {
+    "studymonkey-homework-helper": {
+      "successURLText": "Start Studying!",
+      "name": "StudyMonkey Homework Helper",
+      "monthly": {
+        "stripeProductId": "prod_NTqQASoK03O5fP",
+        "price": 8,
+        "chargebeePlanId": "",
+        "paypalPlanId": "plan.id",
+        "stripePriceId": "price_1MisjzHGybgi7uQGw5MH7VZx"
+      },
+      "successURL": "https://studymonkey.ai/dashboard",
+      "planId": "homework-helper",
+      "spreadsheetId": "1d0elQATs7mpur6IwlyWy_7s2vWvUZYT0nfF2WtTiKjQ",
+      "type": "subscription",
+      "limits": {
+        "devices": 3,
+        "requests": 50
+      },
+      "trial": 14,
+      "annually": {
+        "stripeProductId": "prod_NTqYLkXCOhAwa5",
+        "price": 72,
+        "chargebeePlanId": "",
+        "paypalPlanId": "plan.id",
+        "stripePriceId": "price_1MisrnHGybgi7uQGn0XOVjRo"
+      }
+    }
+  },
+  "reviews": {
+    "sites": ["https://www.trustpilot.com/review/studymonkey.ai"]
+  },
+  "name": "StudyMonkey",
+  "id": "studymonkey",
+  "brand": {
+    "description": "StudyMonkey is an AI-powered tutor that helps you with your homework and studying."
+  },
+  "dashboard": true,
+  "email": "support@studymonkey.ai",
+  "sponsorships": {
+    "acceptable": ["education", "academic"],
+    "unacceptable": ["online homework services", "essay writing service", "online writing services"],
+    "prices": {
+      "guest-post": 40,
+      "link-insertion": 30
+    }
+  },
+  "authentication": {
+    "password": {
+      "enabled": true
+    },
+    "google.com": {
+      "enabled": true
+    }
+  }
+}

package/_notes/NOTES-sub-2.md

@@ -0,0 +1,42 @@
+    // Flags for special conditions
+    flags: {
+      hasDispute: false,
+      hasRefund: false,
+      isDelinquent: false,
+      requiresAction: false,
+      autoRenewEnabled: true,
+      cancellationRequested: false,
+    },
+
+    // Dispute information (if applicable)
+    dispute: {
+      active: false,
+      createdAt: timestamp,
+      amount: 99.99,
+      reason: "fraudulent",
+      status: "warning_needs_response",
+      dueBy: timestamp,
+      evidence: {
+        submitted: false,
+        documents: []
+      }
+    },
+
+    // Refund information (if applicable)
+    refunds: [
+      {
+        id: "refund-xxx",
+        amount: 99.99,
+        reason: "customer_request",
+        createdAt: timestamp,
+        metadata: {}
+      }
+    ],
+
+    // Cancellation details (if cancelled)
+    cancellation: {
+      requestedAt: timestamp,
+      effectiveAt: timestamp, // When it actually ends
+      reason: "too_expensive",
+      feedback: "Price increased too much",
+    },

package/_notes/NOTES-sub-ai.md

@@ -0,0 +1,165 @@
+⏺ I'll help you design a comprehensive storage architecture for your payment system. Let me create a detailed plan
+   using the TodoWrite tool to track our implementation.
+
+⏺ Update Todos
+  ⎿  ☐ Design Firestore collections structure for payment system
+     ☐ Implement active subscription checking before payment intent
+     ☐ Enhance trial eligibility to check both UID and IP address
+     ☐ Create abandoned cart tracking system
+     ☐ Design unified subscription object structure
+     ☐ Create webhook endpoints for Stripe, PayPal, Chargebee
+     ☐ Implement app notification system for subscription events
+
+⏺ Recommended Firestore Collections Structure
+
+  Based on your requirements, I recommend using multiple collections for better scalability and query efficiency:
+
+  1. payment-intents (Abandoned Cart Tracking)
+
+  {
+    id: "CHK-xxx", // checkout session ID
+    app: "app-id",
+    productId: "product-id",
+    userId: "uid", // optional, may be guest
+    email: "email@example.com",
+    ipAddress: "192.168.1.1",
+    status: "pending" | "completed" | "abandoned",
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    lastVisitedAt: timestamp,
+    abandonedEmailsSent: {
+      day1: false,
+      day3: false,
+      day7: false
+    },
+    cartData: {
+      total: 99.99,
+      frequency: "monthly",
+      discount: "CODE20"
+    }
+  }
+
+  2. payment-trials (Trial Eligibility)
+
+  {
+    id: auto,
+    app: "app-id",
+    productId: "product-id",
+    uid: "user-id",
+    ipAddress: "192.168.1.1",
+    startedAt: timestamp,
+    endedAt: timestamp,
+    trialDays: 7
+  }
+
+  3. payment-subscriptions (Unified Subscription Records)
+
+  {
+    id: "sub-xxx",
+    app: "app-id",
+    productId: "product-id",
+    userId: "uid",
+    email: "email@example.com",
+    processor: "stripe" | "paypal" | "chargebee",
+    processorSubscriptionId: "stripe_sub_xxx",
+    status: "active" | "cancelled" | "suspended" | "expired",
+    frequency: "monthly" | "annually",
+    amount: 99.99,
+    currency: "USD",
+    trialEnd: timestamp, // optional
+    currentPeriodStart: timestamp,
+    currentPeriodEnd: timestamp,
+    cancelledAt: timestamp, // optional
+    cancelReason: "string", // optional
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    metadata: {
+      checkoutSessionId: "CHK-xxx",
+      webhookEvents: ["created", "updated", "cancelled"]
+    }
+  }
+
+  4. payment-orders (One-time Payments)
+
+  {
+    id: "order-xxx",
+    app: "app-id",
+    productId: "product-id",
+    userId: "uid",
+    email: "email@example.com",
+    processor: "stripe" | "paypal" | "chargebee",
+    processorOrderId: "stripe_pi_xxx",
+    status: "pending" | "completed" | "failed" | "refunded",
+    amount: 299.99,
+    currency: "USD",
+    createdAt: timestamp,
+    completedAt: timestamp,
+    metadata: {
+      checkoutSessionId: "CHK-xxx"
+    }
+  }
+
+  Implementation Flow
+
+  1. On Checkout Page Load (Client)
+
+  - Generate/retrieve checkout session ID
+  - Send cart data to /payment-v2/cart endpoint
+  - This creates/updates payment-intents document
+
+  2. Before Creating Payment Intent (/payment-v2/intent)
+
+  Check these in parallel:
+  - Active subscription check: Query payment-subscriptions where userId == uid && productId == productId && status
+   == 'active'
+  - Trial eligibility: Query payment-trials where (uid == userId || ipAddress == ip) && productId == productId &&
+  app == appId
+  - ReCAPTCHA verification: Already implemented
+
+  3. After Successful Payment Intent
+
+  - Update payment-intents with processor response data
+  - Store intent as "pending" until webhook confirmation
+
+  4. Webhook Processing (/payment-v2/webhook/[processor])
+
+  - Verify webhook signature
+  - Map processor event to unified status
+  - Update/create payment-subscriptions or payment-orders
+  - Update payment-intents status to "completed"
+  - Send notification to app's webhook endpoint
+
+  5. Abandoned Cart Cron Job
+
+  - Query payment-intents where status == 'pending'
+  - Check age and send appropriate emails
+  - Update abandonedEmailsSent flags
+
+  Endpoints Structure
+
+  /payment-v2/
+    ├── cart/          # Track abandoned carts
+    ├── intent/        # Create payment intent (existing)
+    ├── webhook/
+    │   ├── stripe/
+    │   ├── paypal/
+    │   └── chargebee/
+    ├── subscription/
+    │   └── check/     # Check active subscriptions
+    └── cron/
+        └── abandoned-carts/  # Daily cron for emails
+
+  Key Implementation Points
+
+  1. IP Address Tracking: Add to schema and capture in /payment-v2/intent
+  2. Composite Indexes: Create for efficient queries:
+    - payment-subscriptions: userId + productId + status
+    - payment-trials: uid + productId + app, ipAddress + productId + app
+  3. Unified Status Mapping: Create processor-agnostic status values
+  4. Webhook Security: Verify signatures for each processor
+  5. App Notifications: Implement retry logic with exponential backoff
+
+  Would you like me to start implementing any of these components? I'd suggest starting with:
+  1. Updating the intent endpoint to check active subscriptions
+  2. Enhancing trial eligibility to include IP checking
+  3. Creating the abandoned cart tracking endpoint

package/_notes/NOTES-sub-endpoints.md

@@ -0,0 +1,44 @@
+
+  1. Unified Endpoint Structure
+
+  All processors now use the same endpoint:
+  - Production: https://api.itwcreativeworks.com/payment/intent?processor={PROCESSOR}
+  - Development: http://localhost:5001/your-project-id/us-central1/api/payment/intent?processor={PROCESSOR}
+
+  The endpoint automatically switches based on webManager.isDevelopment().
+
+  2. Standardized Request Body
+
+  All processors send the same request structure:
+  {
+    processor: 'stripe' | 'paypal' | 'chargebee',
+    recaptcha_token: 'token_from_google',
+    processor_data: { /* processor-specific data */ },
+    api_key: 'processor_api_key',
+    is_subscription: true/false  // for PayPal
+  }
+
+  3. Backend Architecture (Firebase Functions)
+
+  Your backend can now have a clean structure:
+  /functions
+    /payment
+      - intent.js  // Main handler
+      /modules
+        - recaptcha.js  // Shared reCAPTCHA verification
+        - stripe.js     // Stripe-specific logic
+        - paypal.js     // PayPal-specific logic
+        - chargebee.js  // Chargebee-specific logic
+
+  The main handler can:
+  1. Verify reCAPTCHA token (common for all)
+  2. Extract processor from query param
+  3. Validate request body
+  4. Delegate to appropriate processor module
+  5. Return standardized response: { url: "checkout_url" }
+
+  This architecture makes it easy to:
+  - Add new payment processors
+  - Share common logic (reCAPTCHA, logging, error handling)
+  - Test locally with Firebase emulator
+  - Maintain consistent API structure

package/_notes/NOTES-sub-example.md

@@ -0,0 +1,92 @@
+/// SUBSCRIPTION
+
+{
+  // Core identification
+  id: "sub-xxx", // Or "ORD-xxx" for orders
+  app: "app-id",
+  product: "product-id",
+  checkout: "chk-xxx", // Links back to payment-intents
+
+  // Auth
+  auth: {
+    uid: "user-uid",
+    email: "user@example.com"
+  },
+
+  // Processor information
+  processor: {
+    id: "stripe", // stripe, paypal, chargebee
+    lastWebhookEvent: "customer.subscription.updated" // Useful for debugging
+  },
+
+  // Type identifier
+  type: "subscription", // or "order" for one-time
+
+  // Status information
+  status: "active", // Same statuses work for orders too
+  access: true, // Computed based on current status and rules
+  frequency: "monthly", // null for one-time orders
+
+  // Customer information
+  customer: {
+    id: "cus-xxx", // Customer ID in the processor
+    name: "John Doe",
+    email: "john.doe@example.com"
+  },
+
+  // Billing information
+  billing: {
+    amount: 99.99,
+    lastPayment: {
+      amount: 99.99,
+      date: {
+        timestamp: "2023-10-01T12:00:00Z",
+        timestampUNIX: 1696156800
+      }
+    },
+    totalRevenue: 299.97, // Lifetime value
+    paymentCount: 3 // Number of successful payments
+  },
+
+  // Trial information (if applicable)
+  trial: {
+    active: true, // Is the trial currently active?
+    claimed: true, // Actually used the trial
+    days: 14,
+    started: {
+      timestamp: "2023-09-15T12:00:00Z",
+      timestampUNIX: 1694745600 // UNIX timestamp
+    }
+  },
+
+  // Supplemental information from the checkout form
+  supplemental: {
+    // Custom form fields
+  },
+
+  // Analytics and tracking
+  utm: {
+    source: "google",
+    medium: "cpc",
+    campaign: "summer_sale",
+    content: "ad_1",
+    term: "keyword"
+  },
+
+  // Original processor data (for debugging)
+  raw: {
+    // Complete webhook payload or API response
+  },
+
+  // Metadata and timestamps
+  meta: {
+    created: {
+      timestamp: "2023-10-01T12:00:00Z",
+      timestampUNIX: 1696156800
+    },
+    updated: {
+      timestamp: "2023-10-02T12:00:00Z",
+      timestampUNIX: 1696243200
+    },
+  },
+}

package/_notes/NOTES-sub-plan.md

@@ -0,0 +1,36 @@
+ok so i need help planning the storage, trial eligibility, and webhooks. im not exactly sure WHAT to store and WHEN to store it. But heres what i know so far
+
+* This system we are building is a centralized checkout system for multiple apps that offer multiple products
+  * This is why we store and keep track of the "app" and "product id" in the database and http calls.
+
+* Prevent users who HAVE A SUBSCRIPTION from buying another one
+  * We will need to check our database to see if the user has an active subscription, as in one that is not cancelled.
+  * If the user has an active subscription, they should NOT be able to buy another one.
+
+* We need to keep track of which users have had a trial already.
+  * There is TRIAL OFFERING and TRIAL ELIGIBILITY. TRIAL OFFERING means a product offers the possibility of a trial (stored in the app.products.[product-id].trial as either 0 or a number of days), and TRIAL ELIGIBILITY means the user is eligible for a trial, which is TRUE if the user has never used a trial for THAT PRODUCT in THAT APP .
+  * For this we need to store the "app", the "product.id", the "auth.uid", and the "geolocation.ip". In other words, for every product in a given app, we cant let a person use the trial more than once. So we should search for a product id of an app and if EITHER the UID or the IP address is found, then we should not allow the user to use the trial. A user can take a trial for a DIFFERNT product in the same app, or a different app entirely. Its only for the same product in the same app that we should not allow a trial more than once.
+  * This is because we dont want people to abuse the trial system.
+  * If the product DOES NOT OFFER A TRIAL, then we should not even check for a trial and assume they are not eligible for one.
+
+* I want to implement a custom "abandoned cart" system
+  * The moment a user lands on the checkout page, we will store the cart somewhere in our database by sending an HTTP request to our server with the cart data.
+  * This way, we can loop through every day and if the user has not completed their checkout, we can send them an email reminding them to complete their purchase, one at 1 day, 3 days, and 7 days after they first landed on the checkout page. The link to go back will have their unique checkout ID in the URL.
+  * When they go to the checkout and send the request to our server, we will check if there is a cart with that ID, and if so, we will reset that cart's timer so we can send more abandoned cart emails if they still do not complete their purchase.
+  * Essentially, every time they visit checkout we will check if they have an abandoned cart, and if so, we will reset the timer for that cart.
+
+* We need to set up webhook listener for stripe, paypal, etc
+  * Update the database with subscription events like when it becomes active, cancelled, etc.
+  * When we receive an event for say, subscription cancelled, we will need to find the record and update the status
+  * Without getting too ahead of ourselves, I would like to DESIGN A PROPRIETARY and UNIFIED object that we can use to store the subscription data and status. This way, no matter what payment provider we use, we can ensure the user has access to their paid features etc without having to consider all the different payment providers own data structures. In this sense, we will create a "resolved" subscription object that contains data regarding when the subscription started, whether it is active/cancelled/suspended (meaning unpaid), the payment provider, the product id, the app id, and any other relevant data we need to store. This way, we can use this object to check if a user has an active subscription or not, regardless of the payment provider.
+  * Also without getting too ahead of ourselves, we will need to send our own HTTP requests to the individual APP that is usinng our unified checkout system. So essentialy we will send a request with the subscription data AND THE RESOLVED SUBSCRIPTION OBJECT to the app that is using our checkout system. This way, the app can update its own database with the subscription data and status, and we can ensure that the user has access to their paid features in THAT SPECIFIC APP.
+
+SO... ALL OF THE ABOVE CONSIDERED... Where should all of these checks happen and where should we store the data? By that I mean, which server functions do we perform these checks and what collections in firestore do we need?
+  * Do we store the entire lifecycle of an order in one collection? Or do we store parts of it in different collections?
+  * Storing in ONE COLLECTION
+    * we would store all the trial related data, the app, product, user, and geolocation data in one collection
+    * We would have a status field that indicates at what stage the order is in such as if its just a payment intent or if it was completed
+  * Storing in multiple collections
+    * We would only store what we need for the specific operation, like we could habe a "payment-trials" collection that keeps track of app, product, user, and IP address, and a "payment-orders" collection that keeps track of the order status, payment provider, etc. and then a "payment-subscriptions" collection that keeps track of the subscription status, start date, end date, etc.
+
+SO... What is the best way to store this data and what endpoints should we set up?

package/_notes/NOTES-sub-status.md

@@ -0,0 +1,123 @@
+Core Subscription Statuses
+
+pending
+- Initial state after checkout
+- Access = false
+- Waiting for first payment confirmation
+- Becomes active or expired
+- Requires additional user action (3D Secure, bank approval)
+
+active
+- Subscription is paid and current
+- Access = true
+- Payment method is valid
+- Next billing date is in the future
+
+trialing
+- User is in free trial period
+- Access = true
+- No charges yet
+- Will convert to active or cancelled when trial ends
+
+paused
+- Temporarily halted by user/admin
+- Access = ?
+- No charges during pause
+- Can be resumed
+- Access may be retained or revoked (configurable)
+- ??? How do we determine access?
+
+suspended
+- One or more payments failed
+- Access = false
+- Access revoked
+- Can be reactivated if payment succeeds
+- Not permanently cancelled
+
+cancelled
+- User intentionally cancelled
+- Access = true
+- Will have access until period end
+- No future charges
+- Transitions to expired at period end
+
+expired
+- Subscription period ended after cancellation
+- Access = false
+- Cannot be reactivated (must create new subscription)
+- Terminal state
+
+
+Stripe → Unified
+
+  {
+    'trialing': 'trialing',
+    'active': 'active',
+    'incomplete': 'incomplete',
+    'incomplete_expired': 'expired',
+    'past_due': 'past_due',
+    'canceled': 'cancelled',
+    'unpaid': 'suspended',
+    'paused': 'paused'
+  }
+
+  PayPal → Unified
+
+  {
+    'APPROVAL_PENDING': 'pending',
+    'APPROVED': 'pending',
+    'ACTIVE': 'active',
+    'SUSPENDED': 'suspended',
+    'CANCELLED': 'cancelled',
+    'EXPIRED': 'expired'
+  }
+
+  Chargebee → Unified
+
+  {
+    'future': 'pending',
+    'in_trial': 'trialing',
+    'active': 'active',
+    'non_renewing': 'cancelled',
+    'paused': 'paused',
+    'cancelled': 'expired',
+    'transferred': 'expired'
+  }
+
+  Status Transition Rules
+
+  const validTransitions = {
+    'pending': ['active', 'trialing', 'incomplete', 'expired'],
+    'trialing': ['active', 'cancelled', 'suspended'],
+    'active': ['cancelled', 'suspended', 'paused'],
+    'suspended': ['active', 'cancelled', 'expired'],
+    'cancelled': ['expired'], // Can only expire after cancellation
+    'paused': ['active', 'cancelled', 'expired'],
+    'incomplete': ['active', 'expired'],
+    'expired': [] // Terminal state
+  };
+
+
+  function computeAccess(subscription) {
+    switch (subscription.status) {
+      case 'active':
+      case 'trialing':
+        return true;
+
+      case 'cancelled':
+        // Has access until current period ends
+        return subscription.billing.currentPeriodEnd > Date.now();
+
+      case 'paused':
+        // Use stored decision from when pause was created
+        return subscription.pause?.accessRetained ?? false;
+
+      case 'pending':
+      case 'suspended':
+      case 'expired':
+        return false;
+
+      default:
+        return false;
+    }
+  }

package/_notes/TODO-frontend.md

@@ -0,0 +1,61 @@
+Frontend TODO
+- sentry in WM
+- chatsy
+  - remake chatsy into a module that we can install here and then users can load it via cdnjs instead of our website
+- contact form with tracking and form-manager and slapform
+
+- save utm tags, send during checkout, signup, etc
+
+- token redirect for auth system (for auth with desktop apps, etc)
+
+ensure blog, article, posts, etc all use proper HTML semantics tags, aria, etc
+
+js refactor
+- make all fns await asyn operations
+- order the fn definitions in the order they are called (most import/toplevel first then the rest. put all tracking fns at the bottom)
+- move export to top and do not use init() fn, just call all fns inside dom.ready OR the main export (depends on the structure)
+- track errors w sentry, not ga4/fb/tiktok
+- add Manager, options back to each index.js for standardization
+- for stanndardization, also ALWAYS set webManager = Manager.webManager in the index.js
+
+pages
+- blog + post
+- about
+- contact
+- team + member
+- extension and download
+
+MAKE OUR CUSTOM THEME CLASSY!!
+
+for pages like pricing, home, about etc
+- put default frontmatter in the default pages so user can override
+
+NEW PLAN NAME STANDARD
+1. Basic, Starter, Pro, Max
+1. Basic, Starter, Plus, Pro
+
+Implement account resolver
+
+https://docs.stripe.com/payments/link/express-checkout-element-link
+
+// // Load page specific scripts
+// if (url.includes('/pricing')) {
+//   dom.loadScript({src: 'https://cdn.itwcreativeworks.com/assets/general/js/pricing-page-handler/index.js'})
+// } else if (url.includes('/download')) {
+//   dom.loadScript({src: 'https://cdn.itwcreativeworks.com/assets/general/js/download-page-handler/index.js'})
+// } else if (url.includes('/browser-extension') || url.includes('/extension')) {
+//   dom.loadScript({src: 'https://cdn.itwcreativeworks.com/assets/general/js/browser-extension-page-handler/index.js'})
+// } else if (window.location.pathname.endsWith('.html')) {
+//   // Redirect and remove .html
+//   window.location.pathname = window.location.pathname.replace('.html', '');
+// }
+
+
+
+// // Save user auth data
+// Manager.auth().ready(function (user) {
+//   setupTracking(user);
+
+//   storage.set('user.auth.uid', user.uid);
+//   storage.set('user.auth.email', user.email);
+// })

package/assets/logos/brandmarks/original/apple-app-store.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="800" width="1200" viewBox="-120.015 -200 1040.13 1200"><linearGradient y2="800" x2="400" y1="0" x1="400" gradientUnits="userSpaceOnUse" id="a"><stop offset="0" stop-color="#0ed4fc"/><stop offset="1" stop-color="#0c57ef"/></linearGradient><path d="M638.4 0H161.6C72.3 0 0 72.3 0 161.6v476.9C0 727.7 72.3 800 161.6 800h476.9c89.2 0 161.6-72.3 161.6-161.6V161.6C800 72.3 727.7 0 638.4 0z" fill="url(#a)"/><path d="M396.6 183.8l16.2-28c10-17.5 32.3-23.4 49.8-13.4 17.5 10 23.4 32.3 13.4 49.8L319.9 462.4h112.9c36.6 0 57.1 43 41.2 72.8H143c-20.2 0-36.4-16.2-36.4-36.4s16.2-36.4 36.4-36.4h92.8l118.8-205.9-37.1-64.4c-10-17.5-4.1-39.6 13.4-49.8 17.5-10 39.6-4.1 49.8 13.4zM256.2 572.7l-35 60.7c-10 17.5-32.3 23.4-49.8 13.4-17.5-10-23.4-32.3-13.4-49.8l26-45c29.4-9.1 53.3-2.1 72.2 20.7zm301.4-110.1h94.7c20.2 0 36.4 16.2 36.4 36.4s-16.2 36.4-36.4 36.4h-52.6l35.5 61.6c10 17.5 4.1 39.6-13.4 49.8-17.5 10-39.6 4.1-49.8-13.4-59.8-103.7-104.7-181.3-134.5-233-30.5-52.6-8.7-105.4 12.8-123.3 23.9 41 59.6 102.9 107.3 185.5z" fill="#fff"/></svg>