@metigan/angular 1.0.0

package/dist/src/lib/metigan.service.d.ts

@@ -0,0 +1,27 @@
+import { MetiganEmailService } from './email.service';
+import { MetiganFormsService } from './forms.service';
+import { MetiganContactsService } from './contacts.service';
+import { MetiganAudiencesService } from './audiences.service';
+import { MetiganTemplatesService } from './templates.service';
+import { MetiganClientOptions } from './types';
+import * as i0 from "@angular/core";
+export declare const METIGAN_CONFIG = "METIGAN_CONFIG";
+export declare class MetiganService {
+    readonly email: MetiganEmailService;
+    readonly forms: MetiganFormsService;
+    readonly contacts: MetiganContactsService;
+    readonly audiences: MetiganAudiencesService;
+    readonly templates: MetiganTemplatesService;
+    private initialized;
+    constructor(emailService: MetiganEmailService, formsService: MetiganFormsService, contactsService: MetiganContactsService, audiencesService: MetiganAudiencesService, templatesService: MetiganTemplatesService, config?: MetiganClientOptions);
+    /**
+     * Initialize all services with API key and options
+     */
+    initialize(options: MetiganClientOptions): void;
+    /**
+     * Check if services are initialized
+     */
+    isInitialized(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetiganService, [null, null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MetiganService>;
+}

package/dist/src/lib/templates.service.d.ts

@@ -0,0 +1,36 @@
+import { Observable } from 'rxjs';
+import { MetiganHttpClient } from './http-client.service';
+import { EmailTemplate, EmailTemplateListResponse, PaginationOptions } from './types';
+import * as i0 from "@angular/core";
+export declare class MetiganTemplatesService {
+    private http;
+    private apiKey;
+    private apiUrl;
+    private timeout;
+    private retryCount;
+    private retryDelay;
+    constructor(http: MetiganHttpClient);
+    /**
+     * Initialize the service with API key and options
+     */
+    initialize(apiKey: string, options?: {
+        apiUrl?: string;
+        timeout?: number;
+        retryCount?: number;
+        retryDelay?: number;
+    }): void;
+    /**
+     * Get default headers
+     */
+    private getHeaders;
+    /**
+     * List all templates
+     */
+    list(options?: PaginationOptions): Observable<EmailTemplateListResponse>;
+    /**
+     * Get template by ID
+     */
+    get(templateId: string): Observable<EmailTemplate>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetiganTemplatesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MetiganTemplatesService>;
+}

package/dist/src/lib/types.d.ts

@@ -0,0 +1,329 @@
+/**
+ * Type definitions for Metigan Angular SDK
+ * @version 1.0.0
+ */
+/**
+ * Email attachment interface for Angular
+ */
+export interface EmailAttachment {
+    content: ArrayBuffer | Uint8Array | string;
+    filename: string;
+    contentType: string;
+}
+/**
+ * Email options interface
+ */
+export interface EmailOptions {
+    /** Sender email address (or Name <email>) */
+    from: string;
+    /** List of recipient email addresses */
+    recipients: string[];
+    /** Email subject */
+    subject: string;
+    /** Email content (HTML supported) - Required if not using templateId */
+    content?: string;
+    /** Template ID for using pre-created templates (optional) */
+    templateId?: string;
+    /** Optional file attachments */
+    attachments?: File[] | EmailAttachment[];
+    /** Optional CC recipients */
+    cc?: string[];
+    /** Optional BCC recipients */
+    bcc?: string[];
+    /** Optional reply-to address */
+    replyTo?: string;
+}
+/**
+ * API response interface for successful email
+ */
+export interface EmailSuccessResponse {
+    success: true;
+    message: string;
+    successfulEmails: {
+        recipient: string;
+        trackingId: string;
+    }[];
+    failedEmails: {
+        recipient: string;
+        error: string;
+    }[];
+    recipientCount: number;
+    emailsRemaining: number;
+}
+/**
+ * API error response interfaces
+ */
+export interface EmailErrorResponse {
+    error: string;
+    message: string;
+}
+/**
+ * Union type for all possible API responses
+ */
+export type EmailApiResponse = EmailSuccessResponse | EmailErrorResponse;
+/**
+ * Form field types
+ */
+export type FormFieldType = 'text' | 'email' | 'number' | 'textarea' | 'select' | 'checkbox' | 'radio' | 'date' | 'phone' | 'url' | 'file' | 'step' | 'password' | 'rating' | 'slider' | 'heading' | 'image-choice' | 'matrix';
+/**
+ * Form field configuration
+ */
+export interface FormFieldConfig {
+    id: string;
+    type: FormFieldType;
+    label: string;
+    placeholder?: string;
+    required?: boolean;
+    helpText?: string;
+    options?: string[];
+    imageUrls?: string[];
+    defaultValue?: string | number | boolean;
+}
+/**
+ * Form settings
+ */
+export interface FormSettings {
+    successMessage?: string;
+    processingMessage?: string;
+    redirectUrl?: string;
+    notifyEmail?: string;
+    enableCaptcha?: boolean;
+    storeResponses?: boolean;
+    allowMultipleSubmissions?: boolean;
+    showProgressBar?: boolean;
+}
+/**
+ * Complete form configuration
+ */
+export interface FormConfig {
+    id?: string;
+    title: string;
+    description?: string;
+    coverImage?: string;
+    fields: FormFieldConfig[];
+    audienceId?: string;
+    settings?: FormSettings;
+    published?: boolean;
+    publishedUrl?: string;
+    slug?: string;
+    analytics?: {
+        views: number;
+        submissions: number;
+        conversionRate?: number;
+    };
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/**
+ * Form submission data
+ */
+export interface FormSubmissionData {
+    [fieldId: string]: any;
+}
+/**
+ * Form submission options
+ */
+export interface FormSubmissionOptions {
+    formId: string;
+    data: FormSubmissionData;
+}
+/**
+ * Form submission response
+ */
+export interface FormSubmissionResponse {
+    success: boolean;
+    message: string;
+    submissionId?: string;
+}
+/**
+ * Form list response
+ */
+export interface FormListResponse {
+    forms: FormConfig[];
+    pagination: {
+        total: number;
+        page: number;
+        limit: number;
+        pages: number;
+    };
+}
+/**
+ * Contact status
+ */
+export type ContactStatus = 'subscribed' | 'unsubscribed' | 'pending' | 'bounced' | 'complained';
+/**
+ * Contact data
+ */
+export interface Contact {
+    id?: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    status: ContactStatus;
+    audienceId: string;
+    tags?: string[];
+    customFields?: Record<string, any>;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/**
+ * Contact creation options
+ */
+export interface CreateContactOptions {
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    audienceId: string;
+    tags?: string[];
+    customFields?: Record<string, any>;
+    status?: ContactStatus;
+}
+/**
+ * Contact update options
+ */
+export interface UpdateContactOptions {
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    tags?: string[];
+    customFields?: Record<string, any>;
+    status?: ContactStatus;
+}
+/**
+ * Contact list filters
+ */
+export interface ContactListFilters {
+    audienceId?: string;
+    status?: ContactStatus;
+    tag?: string;
+    search?: string;
+    page?: number;
+    limit?: number;
+}
+/**
+ * Contact list response
+ */
+export interface ContactListResponse {
+    contacts: Contact[];
+    pagination: {
+        total: number;
+        page: number;
+        limit: number;
+        pages: number;
+    };
+}
+/**
+ * Bulk contact operation result
+ */
+export interface BulkContactResult {
+    success: boolean;
+    imported: number;
+    failed: number;
+    errors?: {
+        email: string;
+        error: string;
+    }[];
+}
+/**
+ * Audience data
+ */
+export interface Audience {
+    id?: string;
+    name: string;
+    description?: string;
+    count: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/**
+ * Audience creation options
+ */
+export interface CreateAudienceOptions {
+    name: string;
+    description?: string;
+}
+/**
+ * Audience update options
+ */
+export interface UpdateAudienceOptions {
+    name?: string;
+    description?: string;
+}
+/**
+ * Audience list response
+ */
+export interface AudienceListResponse {
+    audiences: Audience[];
+    pagination: {
+        total: number;
+        page: number;
+        limit: number;
+        pages: number;
+    };
+}
+/**
+ * Audience statistics
+ */
+export interface AudienceStats {
+    total: number;
+    subscribed: number;
+    unsubscribed: number;
+    pending: number;
+    bounced: number;
+    complained: number;
+    growthRate?: number;
+}
+/**
+ * Email template data
+ */
+export interface EmailTemplate {
+    id: string;
+    name: string;
+    subject: string;
+    components?: any[];
+    styles?: any;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/**
+ * Email template list response
+ */
+export interface EmailTemplateListResponse {
+    templates: EmailTemplate[];
+    pagination: {
+        total: number;
+        page: number;
+        limit: number;
+        pages: number;
+    };
+}
+/**
+ * Pagination options
+ */
+export interface PaginationOptions {
+    page?: number;
+    limit?: number;
+}
+/**
+ * Client options for Metigan
+ */
+export interface MetiganClientOptions {
+    /** API Key */
+    apiKey: string;
+    /** User ID for logging */
+    userId?: string;
+    /** Disable logging */
+    disableLogs?: boolean;
+    /** Request timeout in ms */
+    timeout?: number;
+    /** Number of retries */
+    retryCount?: number;
+    /** Delay between retries in ms */
+    retryDelay?: number;
+    /** Enable debug mode */
+    debug?: boolean;
+    /** Custom API URL */
+    apiUrl?: string;
+}

package/examples/basic.component.ts

@@ -0,0 +1,113 @@
+/**
+ * Basic example of using Metigan Angular SDK
+ */
+
+import { Component, OnInit } from '@angular/core';
+import { MetiganService } from '@metigan/angular';
+
+@Component({
+  selector: 'app-metigan-example',
+  template: `
+    <div>
+      <h2>Metigan SDK Example</h2>
+      
+      <button (click)="sendEmail()">Send Email</button>
+      <button (click)="submitForm()">Submit Form</button>
+      <button (click)="createContact()">Create Contact</button>
+      <button (click)="listAudiences()">List Audiences</button>
+      
+      <div *ngIf="message">{{ message }}</div>
+      <div *ngIf="error" style="color: red;">{{ error }}</div>
+    </div>
+  `
+})
+export class MetiganExampleComponent implements OnInit {
+  message: string = '';
+  error: string = '';
+
+  constructor(private metigan: MetiganService) {}
+
+  ngOnInit() {
+    // Initialize if not done via module
+    if (!this.metigan.isInitialized()) {
+      this.metigan.initialize({
+        apiKey: 'your-api-key-here'
+      });
+    }
+  }
+
+  sendEmail() {
+    this.message = '';
+    this.error = '';
+
+    this.metigan.email.sendEmail({
+      from: 'Your Company <noreply@yourcompany.com>',
+      recipients: ['customer@email.com'],
+      subject: 'Welcome!',
+      content: '<h1>Hello!</h1><p>Thank you for signing up.</p>'
+    }).subscribe({
+      next: (response) => {
+        this.message = `Email sent! ${response.message}`;
+      },
+      error: (error) => {
+        this.error = `Error: ${error.message}`;
+      }
+    });
+  }
+
+  submitForm() {
+    this.message = '';
+    this.error = '';
+
+    this.metigan.forms.submit({
+      formId: 'form-123',
+      data: {
+        'field-email': 'user@email.com',
+        'field-name': 'John Doe'
+      }
+    }).subscribe({
+      next: (response) => {
+        this.message = response.message;
+      },
+      error: (error) => {
+        this.error = `Error: ${error.message}`;
+      }
+    });
+  }
+
+  createContact() {
+    this.message = '';
+    this.error = '';
+
+    this.metigan.contacts.create({
+      email: 'new@email.com',
+      firstName: 'Jane',
+      lastName: 'Doe',
+      audienceId: 'audience-123',
+      tags: ['customer']
+    }).subscribe({
+      next: (contact) => {
+        this.message = `Contact created: ${contact.email}`;
+      },
+      error: (error) => {
+        this.error = `Error: ${error.message}`;
+      }
+    });
+  }
+
+  listAudiences() {
+    this.message = '';
+    this.error = '';
+
+    this.metigan.audiences.list({ page: 1, limit: 10 }).subscribe({
+      next: (response) => {
+        const names = response.audiences.map(a => a.name).join(', ');
+        this.message = `Audiences: ${names}`;
+      },
+      error: (error) => {
+        this.error = `Error: ${error.message}`;
+      }
+    });
+  }
+}
+

package/ng-package.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "./node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "./dist",
+  "lib": {
+    "entryFile": "public-api.ts"
+  }
+}
+

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@metigan/angular",
+  "version": "1.0.0",
+  "description": "Official Metigan SDK for Angular - Email, Forms, Contacts, and Audiences management",
+  "author": "Metigan <support@metigan.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/frantchessico/metigan-angular.git"
+  },
+  "bugs": {
+    "url": "https://github.com/frantchessico/metigan-angular/issues"
+  },
+  "homepage": "https://metigan.com",
+  "keywords": [
+    "angular",
+    "metigan",
+    "email",
+    "email-api",
+    "forms",
+    "contacts",
+    "audiences",
+    "marketing",
+    "marketing-automation",
+    "sdk",
+    "newsletter",
+    "email-sending"
+  ],
+  "peerDependencies": {
+    "@angular/common": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0",
+    "@angular/core": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0",
+    "rxjs": "^7.0.0"
+  },
+  "scripts": {
+    "build": "npx ng-packagr -p ng-package.json",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "devDependencies": {
+    "@angular/common": "^17.0.0",
+    "@angular/compiler": "^17.0.0",
+    "@angular/compiler-cli": "^17.0.0",
+    "@angular/core": "^17.0.0",
+    "ng-packagr": "^17.0.0",
+    "typescript": ">=5.2.0 <5.5.0"
+  },
+  "main": "./dist/bundles/metigan-angular.umd.js",
+  "module": "./dist/fesm2022/metigan-angular.mjs",
+  "es2022": "./dist/fesm2022/metigan-angular.mjs",
+  "esm2022": "./dist/esm2022/metigan-angular.mjs",
+  "fesm2022": "./dist/fesm2022/metigan-angular.mjs",
+  "typings": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "esm2022": "./dist/esm2022/metigan-angular.mjs",
+      "es2022": "./dist/fesm2022/metigan-angular.mjs",
+      "default": "./dist/fesm2022/metigan-angular.mjs"
+    }
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}
+

package/public-api.ts

@@ -0,0 +1,26 @@
+/**
+ * Public API for @metigan/angular
+ * Export all public classes, services, and types
+ */
+
+// Services
+export { MetiganService, METIGAN_CONFIG } from './src/lib/metigan.service';
+export { MetiganEmailService } from './src/lib/email.service';
+export { MetiganFormsService } from './src/lib/forms.service';
+export { MetiganContactsService } from './src/lib/contacts.service';
+export { MetiganAudiencesService } from './src/lib/audiences.service';
+export { MetiganTemplatesService } from './src/lib/templates.service';
+export { MetiganHttpClient } from './src/lib/http-client.service';
+
+// Module
+export { MetiganModule } from './src/lib/metigan.module';
+
+// Errors
+export { MetiganError, ValidationError, ApiError } from './src/lib/errors';
+
+// Types
+export * from './src/lib/types';
+
+// Config
+export { API_URL, SDK_VERSION, DEFAULT_TIMEOUT, DEFAULT_RETRY_COUNT, DEFAULT_RETRY_DELAY, MAX_FILE_SIZE } from './src/lib/config';
+