@churchapps/helpers 1.2.24 → 1.2.26

package/src/PlanHelper.ts

@@ -1,135 +0,0 @@
-import type { PlanInterface, PlanItemInterface, PlanItemContentInterface } from "./interfaces/index.js";
-import type { ContentProviderInterface } from "./contentProviders/ContentProvider.js";
-import { LessonsContentProvider } from "./contentProviders/LessonsContentProvider.js";
-
-export class PlanHelper {
-  private static providers: ContentProviderInterface[] = [new LessonsContentProvider()];
-
-  // Register additional content providers
-  static registerProvider(provider: ContentProviderInterface): void {
-    // Avoid duplicates
-    if (!this.providers.find(p => p.providerId === provider.providerId)) {
-      this.providers.push(provider);
-    }
-  }
-
-  // Replace a provider (useful for configuring with different URLs)
-  static replaceProvider(provider: ContentProviderInterface): void {
-    const index = this.providers.findIndex(p => p.providerId === provider.providerId);
-    if (index >= 0) {
-      this.providers[index] = provider;
-    } else {
-      this.providers.push(provider);
-    }
-  }
-
-  // Main method: populate planItems with their content
-  static async populate(
-    plan: PlanInterface,
-    planItems: PlanItemInterface[]
-  ): Promise<PlanItemInterface[]> {
-    // Flatten hierarchy to get all items
-    const allItems = this.flattenItems(planItems);
-
-    // Group items by provider
-    const itemsByProvider = new Map<ContentProviderInterface, PlanItemInterface[]>();
-
-    for (const item of allItems) {
-      for (const provider of this.providers) {
-        if (provider.canHandle(plan, item)) {
-          const existing = itemsByProvider.get(provider) || [];
-          existing.push(item);
-          itemsByProvider.set(provider, existing);
-          break; // First matching provider wins
-        }
-      }
-    }
-
-    // Fetch content from each provider in parallel
-    const fetchPromises: Promise<void>[] = [];
-    const contentMap = new Map<string, PlanItemContentInterface>();
-
-    for (const [provider, items] of itemsByProvider) {
-      fetchPromises.push(
-        provider.fetchContent(plan, items).then(providerContent => {
-          for (const [itemId, content] of providerContent) {
-            contentMap.set(itemId, content);
-          }
-        })
-      );
-    }
-
-    await Promise.all(fetchPromises);
-
-    // Attach content to items (mutates in place for efficiency)
-    this.attachContent(planItems, contentMap);
-
-    return planItems;
-  }
-
-  // Flatten nested planItems for processing
-  private static flattenItems(items: PlanItemInterface[]): PlanItemInterface[] {
-    const result: PlanItemInterface[] = [];
-
-    const collect = (itemList: PlanItemInterface[]) => {
-      for (const item of itemList) {
-        result.push(item);
-        if (item.children?.length) {
-          collect(item.children);
-        }
-      }
-    };
-
-    collect(items);
-    return result;
-  }
-
-  // Attach content to items recursively
-  private static attachContent(
-    items: PlanItemInterface[],
-    contentMap: Map<string, PlanItemContentInterface>
-  ): void {
-    for (const item of items) {
-      const content = contentMap.get(item.id);
-      if (content) {
-        item.content = content;
-      }
-      if (item.children?.length) {
-        this.attachContent(item.children, contentMap);
-      }
-    }
-  }
-
-  // Convenience: Get the lessons provider for direct lesson operations
-  static getLessonsProvider(): LessonsContentProvider {
-    return this.providers.find(p => p.providerId === "lessons") as LessonsContentProvider;
-  }
-
-  // ============================================
-  // Time Formatting Utilities
-  // ============================================
-
-  /**
-   * Format seconds as MM:SS string
-   * @param seconds - Number of seconds to format
-   * @returns Formatted time string (e.g., "3:45")
-   */
-  static formatTime(seconds: number): string {
-    const mins = Math.floor(seconds / 60);
-    const secs = seconds % 60;
-    return mins + ":" + (secs < 10 ? "0" : "") + secs;
-  }
-
-  /**
-   * Calculate total duration of a section's children
-   * @param section - PlanItem with children
-   * @returns Total seconds from all children
-   */
-  static getSectionDuration(section: PlanItemInterface): number {
-    let totalSeconds = 0;
-    section.children?.forEach((child) => {
-      totalSeconds += child.seconds || 0;
-    });
-    return totalSeconds;
-  }
-}

package/src/UniqueIdHelper.ts

@@ -1,159 +0,0 @@
-export class UniqueIdHelper {
-
-  static chars = [
-    "A",
-    "B",
-    "C",
-    "D",
-    "E",
-    "F",
-    "G",
-    "H",
-    "I",
-    "J",
-    "K",
-    "L",
-    "M",
-    "N",
-    "O",
-    "P",
-    "Q",
-    "R",
-    "S",
-    "T",
-    "U",
-    "V",
-    "W",
-    "X",
-    "Y",
-    "Z",
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "g",
-    "h",
-    "i",
-    "j",
-    "k",
-    "l",
-    "m",
-    "n",
-    "o",
-    "p",
-    "q",
-    "r",
-    "s",
-    "t",
-    "u",
-    "v",
-    "w",
-    "x",
-    "y",
-    "z",
-    "0",
-    "1",
-    "2",
-    "3",
-    "4",
-    "5",
-    "6",
-    "7",
-    "8",
-    "9",
-    "-",
-    "_"
-  ];
-
-  static alphanumericChars = [
-    "A",
-    "B",
-    "C",
-    "D",
-    "E",
-    "F",
-    "G",
-    "H",
-    "I",
-    "J",
-    "K",
-    "L",
-    "M",
-    "N",
-    "O",
-    "P",
-    "Q",
-    "R",
-    "S",
-    "T",
-    "U",
-    "V",
-    "W",
-    "X",
-    "Y",
-    "Z",
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "g",
-    "h",
-    "i",
-    "j",
-    "k",
-    "l",
-    "m",
-    "n",
-    "o",
-    "p",
-    "q",
-    "r",
-    "s",
-    "t",
-    "u",
-    "v",
-    "w",
-    "x",
-    "y",
-    "z",
-    "0",
-    "1",
-    "2",
-    "3",
-    "4",
-    "5",
-    "6",
-    "7",
-    "8",
-    "9"
-  ];
-
-  public static isMissing(obj: any) {
-    if (obj === undefined || obj === null) return true;
-    else if (obj.toString() === "") return true;
-    else return false;
-  }
-
-  public static shortId() {
-    return this.generate(UniqueIdHelper.chars, 11);
-  }
-
-  public static generateAlphanumeric() {
-    return this.generate(UniqueIdHelper.alphanumericChars, 11);
-  }
-
-  public static generate(charList: string[], length: number) {
-    let result = "";
-    for (let i = 0; i < length; i++) {
-      const idx = Math.floor(Math.random() * charList.length);
-      const c = charList[idx];
-      result += c;
-    }
-    return result;
-  }
-
-}

package/src/UserHelper.ts

@@ -1,61 +0,0 @@
-import { ApiHelper } from "./ApiHelper.js";
-import { UserInterface, UserContextInterface, IApiPermission, PersonInterface, LoginUserChurchInterface } from "./interfaces/index.js";
-
-export class UserHelper {
-  static currentUserChurch: LoginUserChurchInterface;
-  static userChurches: LoginUserChurchInterface[];
-  static user: UserInterface;
-  static churchChanged: boolean = false;
-  static person: PersonInterface;
-
-  static selectChurch = async (context?: UserContextInterface, churchId?: string, keyName?: string) => {
-    let userChurch = null;
-
-    if (churchId) {
-      UserHelper.userChurches.forEach(uc => {
-        if (uc.church.id === churchId) userChurch = uc;
-      });
-    } else if (keyName) UserHelper.userChurches.forEach(uc => { if (uc.church.subDomain === keyName) userChurch = uc; });
-    else userChurch = UserHelper.userChurches[0];
-    if (!userChurch) return;
-    else {
-      UserHelper.currentUserChurch = userChurch;
-      UserHelper.setupApiHelper(UserHelper.currentUserChurch);
-      // TODO - remove context code from here and perform the logic in the component itself.
-      if (context) {
-        if (context.userChurch !== null) UserHelper.churchChanged = true;
-        context.setUserChurch(UserHelper.currentUserChurch);
-      }
-    }
-  };
-
-  static setupApiHelper(userChurch: LoginUserChurchInterface) {
-    ApiHelper.setDefaultPermissions(userChurch.jwt);
-    userChurch.apis.forEach(api => { ApiHelper.setPermissions(api.keyName, api.jwt, api.permissions); });
-  }
-
-  static setupApiHelperNoChurch(user: LoginUserChurchInterface) {
-    ApiHelper.setDefaultPermissions(user.jwt);
-  }
-
-  static checkAccess({ api, contentType, action }: IApiPermission): boolean {
-    const config = ApiHelper.getConfig(api);
-    if (!config) return false;
-    const permissions = config.permissions;
-
-    let result = false;
-    if (permissions !== undefined) {
-      permissions.forEach(element => {
-        if (element.contentType === contentType && element.action === action) result = true;
-      });
-    }
-    return result;
-  }
-
-  static createAppUrl(appUrl: string, returnUrl: string) {
-    const config = ApiHelper.getConfig("MembershipApi");
-    const jwt = config?.jwt || "";
-
-    return `${appUrl}/login/?jwt=${jwt}&returnUrl=${returnUrl}`;
-  }
-}

package/src/contentProviders/ContentProvider.ts

@@ -1,15 +0,0 @@
-import type { PlanInterface, PlanItemInterface, PlanItemContentInterface } from "../interfaces/index.js";
-
-export interface ContentProviderInterface {
-  // Unique identifier for this provider
-  readonly providerId: string;
-
-  // Check if this provider handles the given plan/planItem
-  canHandle(plan: PlanInterface, planItem: PlanItemInterface): boolean;
-
-  // Fetch content for multiple planItems (batch for efficiency)
-  fetchContent(
-    plan: PlanInterface,
-    planItems: PlanItemInterface[]
-  ): Promise<Map<string, PlanItemContentInterface>>;
-}

package/src/contentProviders/LessonsContentProvider.ts

@@ -1,278 +0,0 @@
-import { ApiHelper } from "../ApiHelper.js";
-import type { PlanInterface, PlanItemInterface, PlanItemContentInterface, ExternalVenueRefInterface } from "../interfaces/index.js";
-import type { VenuePlanItemsResponseInterface, VenueActionResponseInterface, LessonTreeInterface, LessonActionTreeInterface } from "../interfaces/Lessons.js";
-import type { ContentProviderInterface } from "./ContentProvider.js";
-
-export class LessonsContentProvider implements ContentProviderInterface {
-  readonly providerId = "lessons";
-
-  private lessonsUrl: string;
-
-  constructor(lessonsUrl: string = "https://lessons.church") {
-    this.lessonsUrl = lessonsUrl;
-  }
-
-  canHandle(plan: PlanInterface, planItem: PlanItemInterface): boolean {
-    // Handles: lessonAction, lessonAddOn, lessonSection, and items with relatedId when plan has lesson
-    const lessonTypes = ["lessonAction", "lessonAddOn", "lessonSection"];
-    const hasLessonPlan = plan?.contentType === "venue" || plan?.contentType === "externalVenue";
-
-    if (lessonTypes.includes(planItem.itemType) && planItem.relatedId) return true;
-    if (planItem.itemType === "item" && planItem.relatedId && hasLessonPlan) return true;
-
-    return false;
-  }
-
-  async fetchContent(
-    plan: PlanInterface,
-    planItems: PlanItemInterface[]
-  ): Promise<Map<string, PlanItemContentInterface>> {
-    const result = new Map<string, PlanItemContentInterface>();
-
-    // Group by type for efficient batching
-    const actions = planItems.filter(p => p.itemType === "lessonAction" && p.relatedId);
-    const addOns = planItems.filter(p => p.itemType === "lessonAddOn" && p.relatedId);
-    const sections = planItems.filter(p =>
-      (p.itemType === "lessonSection" || p.itemType === "item") && p.relatedId);
-
-    const externalRef = this.getExternalRef(plan);
-
-    // Build embed URLs for each item
-    for (const item of actions) {
-      result.set(item.id, {
-        provider: this.providerId,
-        embedUrl: externalRef
-          ? `${this.lessonsUrl}/embed/external/${externalRef.externalProviderId}/action/${item.relatedId}`
-          : `${this.lessonsUrl}/embed/action/${item.relatedId}`
-      });
-    }
-
-    for (const item of addOns) {
-      result.set(item.id, {
-        provider: this.providerId,
-        embedUrl: externalRef
-          ? `${this.lessonsUrl}/embed/external/${externalRef.externalProviderId}/addon/${item.relatedId}`
-          : `${this.lessonsUrl}/embed/addon/${item.relatedId}`
-      });
-    }
-
-    for (const item of sections) {
-      result.set(item.id, {
-        provider: this.providerId,
-        embedUrl: externalRef
-          ? `${this.lessonsUrl}/embed/external/${externalRef.externalProviderId}/section/${item.relatedId}`
-          : `${this.lessonsUrl}/embed/section/${item.relatedId}`
-      });
-    }
-
-    return result;
-  }
-
-  // ============================================
-  // Plan/Lesson Association Methods
-  // ============================================
-
-  hasAssociatedLesson(plan: PlanInterface): boolean {
-    return (plan?.contentType === "venue" || plan?.contentType === "externalVenue") && !!plan?.contentId;
-  }
-
-  isExternalVenue(plan: PlanInterface): boolean {
-    return plan?.contentType === "externalVenue";
-  }
-
-  getExternalRef(plan: PlanInterface): ExternalVenueRefInterface | null {
-    if (!this.isExternalVenue(plan) || !plan?.contentId) return null;
-    try {
-      return JSON.parse(plan.contentId);
-    } catch {
-      return null;
-    }
-  }
-
-  getVenueId(plan: PlanInterface): string | null {
-    if (!this.hasAssociatedLesson(plan)) return null;
-    if (this.isExternalVenue(plan)) {
-      return this.getExternalRef(plan)?.venueId || null;
-    }
-    return plan.contentId || null;
-  }
-
-  // ============================================
-  // API Fetch Methods
-  // ============================================
-
-  /**
-   * Fetch venue plan items - the basic hierarchical structure
-   * Returns: headers with children (sections), but sections don't have their actions
-   * Use this for preview mode display
-   */
-  async fetchVenuePlanItems(plan: PlanInterface): Promise<VenuePlanItemsResponseInterface> {
-    if (!this.hasAssociatedLesson(plan)) return { items: [] };
-    const externalRef = this.getExternalRef(plan);
-    if (externalRef) {
-      return await ApiHelper.getAnonymous(
-        `/externalProviders/${externalRef.externalProviderId}/venue/${externalRef.venueId}/planItems`,
-        "LessonsApi"
-      );
-    }
-    return await ApiHelper.getAnonymous(`/venues/public/planItems/${plan.contentId}`, "LessonsApi");
-  }
-
-  /**
-   * Fetch venue actions - sections with their full action lists
-   * Use this for action selection dialogs and full expansion
-   */
-  async fetchVenueActions(plan: PlanInterface): Promise<VenueActionResponseInterface> {
-    if (!this.hasAssociatedLesson(plan)) return { sections: [] };
-    const externalRef = this.getExternalRef(plan);
-    if (externalRef) {
-      return await ApiHelper.getAnonymous(
-        `/externalProviders/${externalRef.externalProviderId}/venue/${externalRef.venueId}/actions`,
-        "LessonsApi"
-      );
-    }
-    return await ApiHelper.getAnonymous(`/venues/public/actions/${plan.contentId}`, "LessonsApi");
-  }
-
-  /**
-   * Fetch the full lesson tree for browsing (programs -> studies -> lessons -> venues)
-   */
-  async fetchLessonTree(): Promise<LessonTreeInterface> {
-    return await ApiHelper.getAnonymous("/lessons/public/tree", "LessonsApi");
-  }
-
-  /**
-   * Fetch the action tree for action selection (includes actions in each venue section)
-   */
-  async fetchActionTree(): Promise<LessonActionTreeInterface> {
-    return await ApiHelper.getAnonymous("/lessons/public/actionTree", "LessonsApi");
-  }
-
-  // ============================================
-  // Display List Methods (for preview/display without full actions)
-  // ============================================
-
-  /**
-   * Get the display list - hierarchical items suitable for preview
-   * Structure: headers -> sections (no actions expanded)
-   * This is the lightweight version for showing what a lesson contains
-   */
-  async getDisplayList(plan: PlanInterface): Promise<PlanItemInterface[]> {
-    const response = await this.fetchVenuePlanItems(plan);
-    return response?.items || [];
-  }
-
-  /**
-   * Get display list with sections only (strip actions from children)
-   * Use this when importing a lesson as editable plan items
-   */
-  async getSectionsOnlyList(plan: PlanInterface): Promise<PlanItemInterface[]> {
-    const response = await this.fetchVenuePlanItems(plan);
-    if (!response?.items) return [];
-
-    return response.items.map(item => ({
-      ...item,
-      children: item.children?.map(section => ({
-        ...section,
-        children: undefined // Remove actions from sections
-      }))
-    }));
-  }
-
-  // ============================================
-  // Expanded List Methods (with full actions)
-  // ============================================
-
-  /**
-   * Get the fully expanded list - items with all actions populated in sections
-   * Merges fetchVenuePlanItems with fetchVenueActions to get complete data
-   */
-  async getExpandedList(plan: PlanInterface): Promise<PlanItemInterface[]> {
-    const [planItemsResponse, actionsResponse] = await Promise.all([
-      this.fetchVenuePlanItems(plan),
-      this.fetchVenueActions(plan)
-    ]);
-
-    if (!planItemsResponse?.items) return [];
-
-    // Create a map of section ID -> actions
-    const sectionActionsMap = new Map<string, PlanItemInterface[]>();
-    if (actionsResponse?.sections) {
-      for (const section of actionsResponse.sections) {
-        if (section.id && section.actions) {
-          sectionActionsMap.set(section.id, section.actions.map(action => ({
-            itemType: "lessonAction",
-            relatedId: action.id,
-            label: action.name,
-            description: action.actionType,
-            seconds: action.seconds
-          })));
-        }
-      }
-    }
-
-    // Recursively expand sections with their actions
-    const expandItem = (item: PlanItemInterface): PlanItemInterface => {
-      if (!item.children) return item;
-
-      return {
-        ...item,
-        children: item.children.map(child => {
-          // If this is a section (has relatedId), try to get its actions
-          if (child.relatedId && sectionActionsMap.has(child.relatedId)) {
-            return {
-              ...child,
-              children: sectionActionsMap.get(child.relatedId)
-            };
-          }
-          // Otherwise recursively process
-          return expandItem(child);
-        })
-      };
-    };
-
-    return planItemsResponse.items.map(expandItem);
-  }
-
-  // ============================================
-  // Embed URL Helpers
-  // ============================================
-
-  /**
-   * Get embed URL for an action
-   */
-  getActionEmbedUrl(actionId: string, externalProviderId?: string): string {
-    if (externalProviderId) {
-      return `${this.lessonsUrl}/embed/external/${externalProviderId}/action/${actionId}`;
-    }
-    return `${this.lessonsUrl}/embed/action/${actionId}`;
-  }
-
-  /**
-   * Get embed URL for an add-on
-   */
-  getAddOnEmbedUrl(addOnId: string, externalProviderId?: string): string {
-    if (externalProviderId) {
-      return `${this.lessonsUrl}/embed/external/${externalProviderId}/addon/${addOnId}`;
-    }
-    return `${this.lessonsUrl}/embed/addon/${addOnId}`;
-  }
-
-  /**
-   * Get embed URL for a section
-   */
-  getSectionEmbedUrl(sectionId: string, externalProviderId?: string): string {
-    if (externalProviderId) {
-      return `${this.lessonsUrl}/embed/external/${externalProviderId}/section/${sectionId}`;
-    }
-    return `${this.lessonsUrl}/embed/section/${sectionId}`;
-  }
-
-  /**
-   * Get the external provider ID from a plan (if external)
-   */
-  getExternalProviderId(plan: PlanInterface): string | null {
-    const externalRef = this.getExternalRef(plan);
-    return externalRef?.externalProviderId || null;
-  }
-}

package/src/contentProviders/index.ts

@@ -1,2 +0,0 @@
-export type { ContentProviderInterface } from "./ContentProvider.js";
-export { LessonsContentProvider } from "./LessonsContentProvider.js";

package/src/index.ts

@@ -1,16 +0,0 @@
-export * from "./interfaces/index.js";
-export { ApiHelper } from "./ApiHelper.js";
-export { AppearanceHelper } from "./AppearanceHelper.js";
-export { ArrayHelper } from "./ArrayHelper.js";
-export { CommonEnvironmentHelper } from "./CommonEnvironmentHelper.js";
-export { CurrencyHelper } from "./CurrencyHelper.js";
-export { DateHelper } from "./DateHelper.js";
-export { DonationHelper } from "./DonationHelper.js";
-export { ErrorHelper } from "./ErrorHelper.js";
-export { EventHelper } from "./EventHelper.js";
-export { FileHelper } from "./FileHelper.js";
-export { PersonHelper } from "./PersonHelper.js";
-export { UserHelper } from "./UserHelper.js";
-export { UniqueIdHelper } from "./UniqueIdHelper.js";
-export { PlanHelper } from "./PlanHelper.js";
-export * from "./contentProviders/index.js";