featurely-site-manager 1.1.26 → 1.1.27

package/dist/cli.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i].startsWith("--") && i + 1 < argv.length && !argv[i + 1].startsWith("--")) {
+      args[argv[i].slice(2)] = argv[i + 1];
+      i++;
+    }
+  }
+  return args;
+}
+async function main() {
+  var _a, _b, _c;
+  const rawArgs = process.argv.slice(2);
+  const isScanPackages = rawArgs[0] === "scan" && rawArgs[1] === "packages";
+  if (!isScanPackages) {
+    console.error(
+      "Usage: featurely-site-manager scan packages --key <api-key> --project <project-id>"
+    );
+    process.exit(1);
+  }
+  const args = parseArgs(rawArgs.slice(2));
+  const apiKey = args["key"];
+  const projectId = args["project"];
+  const baseUrl = (_a = args["url"]) != null ? _a : "https://featurely.no";
+  if (!apiKey) {
+    console.error("Error: --key is required");
+    process.exit(1);
+  }
+  if (!projectId) {
+    console.error("Error: --project is required");
+    process.exit(1);
+  }
+  const pkgPath = resolve(process.cwd(), "package.json");
+  let pkgJson;
+  try {
+    pkgJson = JSON.parse(readFileSync(pkgPath, "utf8"));
+  } catch {
+    console.error(`Error: Could not read package.json at ${pkgPath}`);
+    process.exit(1);
+  }
+  const deps = (_b = pkgJson.dependencies) != null ? _b : {};
+  const devDeps = (_c = pkgJson.devDependencies) != null ? _c : {};
+  const packages = [
+    ...Object.entries(deps).map(([name, version]) => ({
+      name,
+      version: version.replace(/^[\^~>=<]/, "")
+    })),
+    ...Object.entries(devDeps).map(([name, version]) => ({
+      name,
+      version: version.replace(/^[\^~>=<]/, "")
+    }))
+  ];
+  if (packages.length === 0) {
+    console.log("No dependencies found in package.json \u2014 nothing to scan.");
+    process.exit(0);
+  }
+  console.log(`Scanning ${packages.length} packages for project ${projectId}\u2026`);
+  const url = `${baseUrl}/api/projects/${projectId}/packages`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify({ packages })
+    });
+  } catch (err) {
+    console.error("Error: Network request failed.", err);
+    process.exit(1);
+  }
+  if (!res.ok) {
+    const body = await res.text();
+    console.error(`Error: API returned ${res.status}. ${body}`);
+    process.exit(1);
+  }
+  const data = await res.json();
+  const count = Array.isArray(data.packages) ? data.packages.length : packages.length;
+  console.log(
+    `\u2713 Scan complete. ${count} packages analysed. View results in your Featurely dashboard.`
+  );
+}
+main();

package/dist/index.d.mts

@@ -0,0 +1,224 @@
+type MessageType = "info" | "warning" | "error" | "success";
+type MessagePosition = "top" | "bottom";
+type MessageStyle = "banner" | "toast";
+interface StatusMessage {
+    id: string;
+    type: MessageType;
+    title: string;
+    message: string;
+    icon?: string;
+    dismissible: boolean;
+    position: MessagePosition;
+    style: MessageStyle;
+    expiresAt?: string;
+    startsAt?: string;
+    targetPages?: string[];
+    cta?: {
+        text: string;
+        url: string;
+        action?: string;
+    };
+    priority?: number;
+}
+interface FeatureFlag {
+    id: string;
+    key: string;
+    name: string;
+    description?: string;
+    enabled: boolean;
+    rolloutPercentage?: number;
+    targetEmails?: string[];
+    excludeEmails?: string[];
+    variants?: {
+        key: string;
+        name: string;
+        weight: number;
+    }[];
+    defaultVariant?: string;
+    targetAttributes?: Array<{
+        attribute: string;
+        operator: "equals" | "not_equals" | "contains" | "greater_than" | "less_than";
+        value: string | number | boolean;
+    }>;
+}
+interface MaintenanceConfig {
+    enabled: boolean;
+    type: "default" | "custom";
+    customHtml?: string;
+    expectedRestoration?: string;
+    showStatusLink: boolean;
+    statusPageUrl?: string;
+    whitelist: {
+        localStorageKeys?: string[];
+        emails?: string[];
+        ips?: string[];
+    };
+}
+interface AppVersion {
+    version: string;
+    title: string;
+    releaseNotes?: string;
+    downloadUrl?: string;
+    platformUrls?: Record<string, string>;
+    releaseDate: string;
+    isBeta?: boolean;
+    rolloutPercentage?: number;
+}
+interface VersionCheckResponse {
+    updateAvailable: boolean;
+    updateRequired: boolean;
+    updateRecommended: boolean;
+    updateType?: "major" | "minor" | "patch" | "hash" | "unknown";
+    latestVersion?: AppVersion;
+}
+interface VersionUpdateRules {
+    major?: "required" | "available";
+    minor?: "required" | "available";
+    patch?: "required" | "recommended" | "available";
+}
+interface SiteConfig {
+    maintenance: MaintenanceConfig;
+    messages: StatusMessage[];
+    featureFlags: FeatureFlag[];
+    lastUpdated: string;
+}
+interface SiteManagerConfig {
+    apiKey: string;
+    projectId: string;
+    apiUrl?: string;
+    environment?: string;
+    pollInterval?: number;
+    userEmail?: string;
+    bypassCheck?: () => boolean;
+    onMaintenanceEnabled?: (config: MaintenanceConfig) => void;
+    onMaintenanceDisabled?: () => void;
+    onMessageReceived?: (message: StatusMessage) => void;
+    onMessageDismissed?: (messageId: string) => void;
+    onFeatureFlagsUpdated?: (flags: FeatureFlag[]) => void;
+    userId?: string;
+    customAttributes?: Record<string, string | number | boolean>;
+    bootstrapFlags?: Record<string, boolean>;
+    enableAnalytics?: boolean;
+    analyticsFlushInterval?: number;
+    appVersion?: string;
+    enableVersionCheck?: boolean;
+    versionCheckInterval?: number;
+    onUpdateAvailable?: (versionInfo: VersionCheckResponse) => void;
+    onUpdateRequired?: (versionInfo: VersionCheckResponse) => void;
+    platform?: string;
+    updateRules?: VersionUpdateRules;
+    onError?: (error: Error) => void;
+    debugMode?: boolean;
+    debugSecret?: string;
+    autoInjectBanners?: boolean;
+    autoCaptureClicks?: boolean;
+}
+declare class SiteManager {
+    private config;
+    private siteConfig;
+    private configETag;
+    private pollIntervalId;
+    private versionCheckIntervalId;
+    private messageContainers;
+    private dismissedMessages;
+    private featureFlagBuckets;
+    private analyticsQueue;
+    private analyticsFlushIntervalId;
+    private sessionId;
+    private consecutiveFetchFailures;
+    private pageTrackingSetup;
+    private currentPagePath;
+    private currentPageSearch;
+    private pageEntryTime;
+    private static readonly MAX_CONSECUTIVE_FAILURES;
+    private lastVersionCheck;
+    private debugOverlayEl;
+    private debugRefreshId;
+    private debugLogs;
+    private networkLog;
+    private analyticsEventsSent;
+    private debugMinimized;
+    private debugTab;
+    private recentAnalyticsEvents;
+    private testFlagKey;
+    private testFeedback;
+    private errorCount;
+    private consoleIntercepted;
+    private visitorId;
+    private flagOverrides;
+    private originalConsoleError;
+    private originalConsoleWarn;
+    constructor(config: SiteManagerConfig);
+    init(): Promise<void>;
+    destroy(): void;
+    setUser(email: string, userId?: string, customAttributes?: Record<string, string | number | boolean>): void;
+    isFeatureEnabled(flagKey: string, defaultValue?: boolean): boolean;
+    getFeatureVariant(flagKey: string): string | null;
+    getAllFeatureFlags(): FeatureFlag[];
+    getEnabledFeatures(): string[];
+    getActiveEnvironment(): {
+        id: string;
+        name: string;
+        slug: string;
+    } | null;
+    isErrorLoggingEnabled(): boolean;
+    overrideFlag(flagKey: string, value: boolean | null): void;
+    isInMaintenanceMode(): boolean;
+    getActiveMessages(): StatusMessage[];
+    refresh(): Promise<void>;
+    trackEvent(eventName: string, properties?: Record<string, string | number | boolean>): void;
+    track404(path?: string): void;
+    private fetchConfig;
+    private startPolling;
+    private stopPolling;
+    private startAnalyticsFlushing;
+    private stopAnalyticsFlushing;
+    private flushAnalytics;
+    private debugLog;
+    private debugNetwork;
+    private stopDebugOverlay;
+    private setupGlobalErrorCapture;
+    private setupDebugOverlay;
+    private renderDebugOverlay;
+    private handleTestAction;
+    private parseUtmParams;
+    private setupWebVitals;
+    private setupOutboundLinkTracking;
+    private setupAutoClickCapture;
+    private setupPageTracking;
+    private trackPageView;
+    private trackPageExit;
+    private onNavigate;
+    private generateSessionId;
+    checkVersion(currentVersion?: string): Promise<VersionCheckResponse | null>;
+    forceUpdateWeb(): Promise<void>;
+    getLastVersionCheck(): VersionCheckResponse | null;
+    private startVersionChecking;
+    private stopVersionChecking;
+    private resolveEnvironment;
+    private hostnameMatchesEnv;
+    private matchHostnamePattern;
+    private evaluateFeatureFlag;
+    private getUserBucket;
+    private simpleHash;
+    private getAnonymousId;
+    private getOrCreateVisitorId;
+    private checkMaintenanceMode;
+    private enableMaintenanceMode;
+    private disableMaintenanceMode;
+    private shouldBypassMaintenance;
+    private showMaintenancePage;
+    private hideMaintenancePage;
+    private getDefaultMaintenanceHtml;
+    private updateMessages;
+    private showMessage;
+    private dismissMessage;
+    private clearMessages;
+    private handleMessageAction;
+    private getDefaultIcon;
+    private loadDismissedMessages;
+    private saveDismissedMessages;
+    private injectStyles;
+}
+
+export { type AppVersion, type FeatureFlag, type MaintenanceConfig, type MessagePosition, type MessageStyle, type MessageType, type SiteConfig, SiteManager, type SiteManagerConfig, type StatusMessage, type VersionCheckResponse, type VersionUpdateRules, SiteManager as default };