@aippy/runtime 0.1.0

package/README.md

@@ -0,0 +1,117 @@
+# @aippy/runtime
+
+Runtime SDK for Aippy projects providing device functionality, platform detection, and utility functions.
+
+## Installation
+
+```bash
+npm install @aippy/runtime
+```
+
+## Usage
+
+### Core
+
+```typescript
+import { AippyConfig, mergeConfig } from '@aippy/runtime/core';
+
+const config = mergeConfig({
+  debug: true,
+  apiBaseUrl: 'https://api.example.com'
+});
+```
+
+### Device APIs
+
+```typescript
+import { camera, geolocation, sensors, fileSystem } from '@aippy/runtime/device';
+
+// Camera
+const stream = await camera.getStream();
+const photo = await camera.capturePhoto({ quality: 'high' });
+
+// Geolocation
+const position = await geolocation.getCurrentPosition();
+const watchId = geolocation.watchPosition((pos) => {
+  console.log('Position:', pos);
+});
+
+// Sensors
+const orientation = await sensors.getOrientation();
+const cleanup = sensors.watchOrientation((data) => {
+  console.log('Orientation:', data);
+});
+
+// File System
+const files = await fileSystem.openFile({ multiple: true });
+await fileSystem.saveFile(blob, 'filename.txt');
+```
+
+### Utils
+
+```typescript
+import { platform, performanceMonitor, pwa } from '@aippy/runtime/utils';
+
+// Platform detection
+const info = platform.getPlatformInfo();
+const capabilities = platform.getCapabilities();
+
+// Performance monitoring
+const metrics = await performanceMonitor.getCoreWebVitals();
+const timing = performanceMonitor.getNavigationTiming();
+
+// PWA utilities
+const pwaInfo = pwa.getPWAInfo();
+await pwa.registerServiceWorker('/sw.js');
+await pwa.sendNotification('Hello!');
+```
+
+## Packages
+
+- `@aippy/runtime/core` - Core types and configuration
+- `@aippy/runtime/device` - Device APIs (camera, geolocation, sensors, file system)
+- `@aippy/runtime/utils` - Platform detection, performance monitoring, PWA utilities
+
+## Publishing
+
+This package is published to the npm public registry. The build process ensures that only compiled JavaScript files and TypeScript declarations are included in the published package - no source code is exposed.
+
+### Build Process
+
+- Compiles TypeScript to JavaScript
+- Generates TypeScript declaration files
+- Removes source maps to protect source code
+- Only includes `dist/` directory and `README.md` in the published package
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build
+pnpm run build
+
+# Type check
+pnpm run type-check
+
+# Lint
+pnpm run lint
+
+# Format
+pnpm run format
+
+# Publish (for maintainers)
+pnpm run publish:patch  # 0.0.0 -> 0.0.1
+pnpm run publish:minor  # 0.0.0 -> 0.1.0
+pnpm run publish:major  # 0.0.0 -> 1.0.0
+```
+
+## Support
+
+- **Homepage**: [https://aippy.ai](https://aippy.ai)
+- **Support**: [Discord Community](https://discord.com/invite/G94ZAx6gVq)
+
+## License
+
+UNLICENSED - This is a proprietary SDK. All rights reserved.

package/dist/core/config.d.ts

@@ -0,0 +1,13 @@
+import { AippyConfig } from './types';
+/**
+ * Default configuration
+ */
+export declare const DEFAULT_CONFIG: AippyConfig;
+/**
+ * Get configuration from environment variables
+ */
+export declare function getConfigFromEnv(): Partial<AippyConfig>;
+/**
+ * Merge configuration with defaults
+ */
+export declare function mergeConfig(userConfig?: Partial<AippyConfig>): AippyConfig;

package/dist/core/errors.d.ts

@@ -0,0 +1,23 @@
+import { AippyError } from './types';
+/**
+ * Custom error class
+ */
+export declare class AippyRuntimeError extends Error implements AippyError {
+    readonly code: string;
+    readonly context?: Record<string, unknown>;
+    constructor(message: string, code?: string, context?: Record<string, unknown>);
+}
+/**
+ * Common error codes
+ */
+export declare const ERROR_CODES: {
+    readonly NOT_SUPPORTED: "NOT_SUPPORTED";
+    readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+    readonly INVALID_CONFIG: "INVALID_CONFIG";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+};
+/**
+ * Create a standardized error
+ */
+export declare function createError(message: string, code?: keyof typeof ERROR_CODES, context?: Record<string, unknown>): AippyRuntimeError;

package/dist/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './config';
+export * from './errors';
+export * from './version';

package/dist/core/index.js

@@ -0,0 +1,59 @@
+import { A, E, c } from "../errors-DAz5_jDJ.js";
+const DEFAULT_CONFIG = {
+  mode: "development",
+  debug: false,
+  apiBaseUrl: void 0,
+  headers: {}
+};
+function getConfigFromEnv() {
+  const config = {};
+  if (typeof process !== "undefined" && process.env) {
+    if (process.env.NODE_ENV) {
+      config.mode = process.env.NODE_ENV;
+    }
+    if (process.env.AIPPY_DEBUG) {
+      config.debug = process.env.AIPPY_DEBUG === "true";
+    }
+    if (process.env.AIPPY_API_BASE_URL) {
+      config.apiBaseUrl = process.env.AIPPY_API_BASE_URL;
+    }
+  }
+  return config;
+}
+function mergeConfig(userConfig) {
+  const envConfig = getConfigFromEnv();
+  return {
+    ...DEFAULT_CONFIG,
+    ...envConfig,
+    ...userConfig,
+    headers: {
+      ...DEFAULT_CONFIG.headers,
+      ...envConfig.headers,
+      ...userConfig?.headers
+    }
+  };
+}
+const version = "0.1.0";
+const packageJson = {
+  version
+};
+const VERSION = packageJson.version;
+const SDK_NAME = "@aippy/runtime";
+function getVersionInfo() {
+  return {
+    name: SDK_NAME,
+    version: VERSION,
+    buildTime: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+export {
+  A as AippyRuntimeError,
+  DEFAULT_CONFIG,
+  E as ERROR_CODES,
+  SDK_NAME,
+  VERSION,
+  c as createError,
+  getConfigFromEnv,
+  getVersionInfo,
+  mergeConfig
+};

package/dist/core/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Core types and interfaces
+ */
+export interface AippyConfig {
+    /** Environment mode */
+    mode: 'development' | 'production' | 'test';
+    /** Debug mode */
+    debug: boolean;
+    /** API base URL */
+    apiBaseUrl?: string;
+    /** Custom headers */
+    headers?: Record<string, string>;
+}
+export interface AippyRuntimeOptions {
+    /** Configuration object */
+    config?: Partial<AippyConfig>;
+    /** Custom error handler */
+    onError?: (error: Error) => void;
+}
+export interface DeviceCapabilities {
+    /** Camera support */
+    camera: boolean;
+    /** Geolocation support */
+    geolocation: boolean;
+    /** File system access support */
+    fileSystem: boolean;
+    /** Device orientation support */
+    orientation: boolean;
+    /** Vibration support */
+    vibration: boolean;
+}
+export interface PlatformInfo {
+    /** Platform name */
+    name: 'ios' | 'android' | 'windows' | 'macos' | 'linux' | 'unknown';
+    /** Platform version */
+    version?: string;
+    /** Browser name */
+    browser: 'chrome' | 'firefox' | 'safari' | 'edge' | 'unknown';
+    /** Browser version */
+    browserVersion?: string;
+    /** Is mobile device */
+    isMobile: boolean;
+    /** Is desktop device */
+    isDesktop: boolean;
+}
+export interface AippyError extends Error {
+    /** Error code */
+    code: string;
+    /** Error context */
+    context?: Record<string, unknown>;
+}

package/dist/core/version.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Version information
+ */
+export declare const VERSION: string;
+export declare const SDK_NAME = "@aippy/runtime";
+/**
+ * Get SDK version info
+ */
+export declare function getVersionInfo(): {
+    name: string;
+    version: string;
+    buildTime: string;
+};

package/dist/core.d.ts

@@ -0,0 +1,2 @@
+export * from './core/index'
+export {}

package/dist/device/camera.d.ts

@@ -0,0 +1,27 @@
+import { CameraOptions, CameraResult } from './types';
+/**
+ * Camera functionality wrapper
+ */
+export declare class CameraAPI {
+    private stream;
+    /**
+     * Check if camera is supported
+     */
+    isSupported(): boolean;
+    /**
+     * Get camera stream
+     */
+    getStream(options?: CameraOptions): Promise<MediaStream>;
+    /**
+     * Capture photo from stream
+     */
+    capturePhoto(options?: CameraOptions): Promise<CameraResult>;
+    /**
+     * Stop camera stream
+     */
+    stopStream(): void;
+}
+/**
+ * Camera API instance
+ */
+export declare const camera: CameraAPI;

package/dist/device/file-system.d.ts

@@ -0,0 +1,42 @@
+import { FileSystemOptions, FileSystemResult } from './types';
+/**
+ * File system functionality wrapper
+ */
+export declare class FileSystemAPI {
+    /**
+     * Check if file system access is supported
+     */
+    isSupported(): boolean;
+    /**
+     * Check if legacy file input is supported
+     */
+    isLegacySupported(): boolean;
+    /**
+     * Open file picker (modern API)
+     */
+    openFilePicker(options?: FileSystemOptions): Promise<FileSystemResult>;
+    /**
+     * Open file picker (legacy fallback)
+     */
+    openFilePickerLegacy(options?: FileSystemOptions): Promise<FileSystemResult>;
+    /**
+     * Open file picker with fallback
+     */
+    openFile(options?: FileSystemOptions): Promise<FileSystemResult>;
+    /**
+     * Save file
+     */
+    saveFile(blob: Blob, filename: string): Promise<void>;
+    /**
+     * Read file as text
+     */
+    readAsText(file: File): Promise<string>;
+    /**
+     * Read file as data URL
+     */
+    readAsDataURL(file: File): Promise<string>;
+}
+/**
+ * File system API instance
+ */
+export declare const fileSystem: FileSystemAPI;

package/dist/device/geolocation.d.ts

@@ -0,0 +1,26 @@
+import { GeolocationOptions, GeolocationResult } from './types';
+/**
+ * Geolocation functionality wrapper
+ */
+export declare class GeolocationAPI {
+    /**
+     * Check if geolocation is supported
+     */
+    isSupported(): boolean;
+    /**
+     * Get current position
+     */
+    getCurrentPosition(options?: GeolocationOptions): Promise<GeolocationResult>;
+    /**
+     * Watch position changes
+     */
+    watchPosition(callback: (position: GeolocationResult) => void, options?: GeolocationOptions): number;
+    /**
+     * Clear position watch
+     */
+    clearWatch(watchId: number): void;
+}
+/**
+ * Geolocation API instance
+ */
+export declare const geolocation: GeolocationAPI;

package/dist/device/haptics.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Haptic feedback functionality for device vibration
+ */
+interface AippyMessage {
+    command: string;
+    parameters: number | number[];
+}
+interface WebKitMessageHandlers {
+    aippyListener: {
+        postMessage: (data: AippyMessage) => void;
+    };
+}
+interface WebKit {
+    messageHandlers: WebKitMessageHandlers;
+}
+declare global {
+    interface Window {
+        webkit?: WebKit;
+    }
+}
+/**
+ * Vibrate the device with the specified pattern
+ * @param pattern - Vibration pattern (number for duration, or array of numbers for pattern)
+ * @returns Promise that resolves when vibration is complete
+ */
+export declare function vibrate(pattern: number | number[]): Promise<void>;
+export {};

package/dist/device/index.d.ts

@@ -0,0 +1,6 @@
+export * from './camera';
+export * from './geolocation';
+export * from './sensors';
+export * from './file-system';
+export * from './haptics';
+export * from './types';