@platform-blocks/ui 0.1.1

package/lib/components/Calendar/Day.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { DayProps } from './types';
+export declare const Day: React.FC<DayProps>;

package/lib/components/Calendar/Month.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { MonthProps } from './types';
+export declare const Month: React.FC<MonthProps>;

package/lib/components/Calendar/MonthPicker.d.ts

@@ -0,0 +1,2 @@
+export { MonthPicker } from '../MonthPicker';
+export type { MonthPickerProps } from '../MonthPicker/types';

package/lib/components/Calendar/YearPicker.d.ts

@@ -0,0 +1,2 @@
+export { YearPicker } from '../YearPicker';
+export type { YearPickerProps } from '../YearPicker/types';

package/lib/components/Calendar/index.d.ts

@@ -0,0 +1,8 @@
+export { Calendar } from './Calendar';
+export { MiniCalendar } from '../MiniCalendar/MiniCalendar';
+export { MonthPicker } from '../MonthPicker';
+export { YearPicker } from '../YearPicker';
+export { Month } from './Month';
+export { Day } from './Day';
+export { dateUtils } from './utils';
+export type { CalendarProps, MiniCalendarProps, MonthPickerProps, YearPickerProps, MonthProps, DayProps, CalendarLevel, CalendarType, CalendarValue, } from './types';

package/lib/components/Calendar/types.d.ts

@@ -0,0 +1,92 @@
+import React from 'react';
+import { ViewStyle } from 'react-native';
+import { SizeValue } from '../../core/theme/types';
+export type CalendarLevel = 'month' | 'year' | 'decade';
+export type CalendarType = 'single' | 'multiple' | 'range';
+export type CalendarValue = Date | Date[] | [Date | null, Date | null] | null;
+export interface CalendarProps {
+    level?: CalendarLevel;
+    defaultLevel?: CalendarLevel;
+    onLevelChange?: (level: CalendarLevel) => void;
+    date?: Date;
+    defaultDate?: Date;
+    onDateChange?: (date: Date) => void;
+    value?: CalendarValue;
+    onChange?: (value: CalendarValue) => void;
+    type?: CalendarType;
+    minDate?: Date;
+    maxDate?: Date;
+    excludeDate?: (date: Date) => boolean;
+    locale?: string;
+    firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    weekendDays?: number[];
+    withCellSpacing?: boolean;
+    hideOutsideDates?: boolean;
+    hideWeekdays?: boolean;
+    highlightToday?: boolean;
+    numberOfMonths?: number;
+    getDayProps?: (date: Date) => Partial<DayProps>;
+    renderDay?: (date: Date) => React.ReactNode;
+    size?: SizeValue;
+    static?: boolean;
+}
+export interface MiniCalendarProps {
+    value?: Date | null;
+    onChange?: (date: Date | null) => void;
+    numberOfDays?: number;
+    defaultDate?: Date;
+    minDate?: Date;
+    maxDate?: Date;
+    nextControlProps?: any;
+    previousControlProps?: any;
+    getDayProps?: (date: Date) => Partial<DayProps>;
+    renderDay?: (date: Date) => React.ReactNode;
+    locale?: string;
+    size?: SizeValue;
+}
+export type { MonthPickerProps } from '../MonthPicker/types';
+export type { YearPickerProps } from '../YearPicker/types';
+export interface MonthProps {
+    month: Date;
+    value?: CalendarValue;
+    onChange?: (value: CalendarValue) => void;
+    type?: CalendarType;
+    hoveredDate?: Date | null;
+    onDayHover?: (date: Date) => void;
+    onDayHoverEnd?: () => void;
+    minDate?: Date;
+    maxDate?: Date;
+    excludeDate?: (date: Date) => boolean;
+    firstDayOfWeek?: number;
+    weekendDays?: number[];
+    hideOutsideDates?: boolean;
+    hideWeekdays?: boolean;
+    highlightToday?: boolean;
+    withCellSpacing?: boolean;
+    getDayProps?: (date: Date) => Partial<DayProps>;
+    renderDay?: (date: Date) => React.ReactNode;
+    size?: SizeValue;
+    locale?: string;
+}
+export interface DayProps {
+    date: Date;
+    selected?: boolean;
+    inRange?: boolean;
+    firstInRange?: boolean;
+    lastInRange?: boolean;
+    previewed?: boolean;
+    previewedInRange?: boolean;
+    previewedFirstInRange?: boolean;
+    previewedLastInRange?: boolean;
+    weekend?: boolean;
+    outside?: boolean;
+    today?: boolean;
+    disabled?: boolean;
+    onPress?: () => void;
+    onMouseEnter?: () => void;
+    onMouseLeave?: () => void;
+    size?: SizeValue;
+    style?: ViewStyle;
+    children?: React.ReactNode;
+    [key: string]: any;
+}

package/lib/components/Calendar/utils.d.ts

@@ -0,0 +1,31 @@
+export declare const dateUtils: {
+    startOfDay: (date: Date) => Date;
+    endOfDay: (date: Date) => Date;
+    startOfMonth: (date: Date) => Date;
+    endOfMonth: (date: Date) => Date;
+    startOfYear: (date: Date) => Date;
+    endOfYear: (date: Date) => Date;
+    addDays: (date: Date, days: number) => Date;
+    addMonths: (date: Date, months: number) => Date;
+    addYears: (date: Date, years: number) => Date;
+    isSameDay: (date1: Date, date2: Date) => boolean;
+    isSameMonth: (date1: Date, date2: Date) => boolean;
+    isSameYear: (date1: Date, date2: Date) => boolean;
+    isToday: (date: Date) => boolean;
+    isWeekend: (date: Date, weekendDays?: number[]) => boolean;
+    isInRange: (date: Date, start: Date | null, end: Date | null) => boolean;
+    isBetween: (date: Date, start: Date | null, end: Date | null) => boolean;
+    getDaysInMonth: (date: Date) => number;
+    getMonthCalendar: (date: Date, firstDayOfWeek?: number) => Date[][];
+    getMonthNames: (locale?: string) => string[];
+    getWeekdayNames: (locale?: string, format?: "long" | "short" | "narrow") => string[];
+    formatDate: (date: Date, format: string, locale?: string) => string;
+    parseDate: (value: string) => Date | null;
+    getDecadeRange: (year: number) => [number, number];
+    getYearsInDecade: (date: Date) => number[];
+    clampDate: (date: Date, minDate?: Date, maxDate?: Date) => Date;
+    isDateDisabled: (date: Date, minDate?: Date, maxDate?: Date, excludeDate?: (date: Date) => boolean) => boolean;
+    getDaysInRange: (startDate: Date, numberOfDays: number) => Date[];
+    startOfWeek: (date: Date, firstDayOfWeek?: number) => Date;
+    getMonthsInYear: (year: number) => Date[];
+};

package/lib/components/Can/Can.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import { CanProps, CanWithConditionsProps, CannotProps, PermissionGateProps } from './types';
+/**
+ * Can Component - Renders children if permission is granted
+ */
+export declare const Can: React.FC<CanProps>;
+/**
+ * Can Component with conditions - For object-level permissions
+ */
+export declare const CanWithConditions: React.FC<CanWithConditionsProps>;
+/**
+ * Cannot Component - Renders children if permission is NOT granted
+ */
+export declare const Cannot: React.FC<CannotProps>;
+/**
+ * Permission Gate - Requires ALL permissions to pass
+ */
+export declare const PermissionGate: React.FC<PermissionGateProps>;
+/**
+ * Higher-Order Component for permission checking
+ */
+export declare function withCan<P extends object>(action: string, subject?: any, field?: string): (Component: React.ComponentType<P>) => React.FC<P & {
+    fallback?: React.ReactNode;
+}>;
+/**
+ * Higher-Order Component for permission denial checking
+ */
+export declare function withCannot<P extends object>(action: string, subject?: any, field?: string): (Component: React.ComponentType<P>) => React.FC<P & {
+    fallback?: React.ReactNode;
+}>;

package/lib/components/Can/PermissionDemo.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const PermissionDemo: React.FC;

package/lib/components/Can/ability.d.ts

@@ -0,0 +1,89 @@
+import { Action, Subject, Field, PermissionRule, PermissionCheck, Ability } from './types';
+/**
+ * Core Ability class for managing permissions
+ */
+export declare class AbilityCore implements Ability {
+    private rules;
+    private cache;
+    constructor(rules?: PermissionRule[]);
+    /**
+     * Check if action is allowed on subject
+     */
+    can(action: Action, subject: Subject, field?: Field): boolean;
+    /**
+     * Check if action is forbidden on subject
+     */
+    cannot(action: Action, subject: Subject, field?: Field): boolean;
+    /**
+     * Get detailed permission check result
+     */
+    check(action: Action, subject: Subject, field?: Field): PermissionCheck;
+    /**
+     * Update ability rules and clear cache
+     */
+    update(rules: PermissionRule[]): void;
+    /**
+     * Get all current rules
+     */
+    getRules(): PermissionRule[];
+    /**
+     * Clear all rules and cache
+     */
+    clear(): void;
+    /**
+     * Perform the actual permission check
+     */
+    private performCheck;
+    /**
+     * Check if a rule matches the current permission check
+     */
+    private ruleMatches;
+    /**
+     * Check if subject matches any of the rule subjects
+     */
+    private subjectMatches;
+    /**
+     * Check if conditions match the subject object
+     */
+    private conditionsMatch;
+    /**
+     * Check if two values match (handles various comparison types)
+     */
+    private valuesMatch;
+    /**
+     * Generate cache key for permission check
+     */
+    private getCacheKey;
+}
+/**
+ * Create a new Ability instance
+ */
+export declare function createAbility(rules?: PermissionRule[]): Ability;
+/**
+ * Helper to create permission rules
+ */
+export declare const definePermissions: (rules: PermissionRule[]) => PermissionRule[];
+/**
+ * Common permission actions
+ */
+export declare const Actions: {
+    readonly CREATE: "create";
+    readonly READ: "read";
+    readonly UPDATE: "update";
+    readonly DELETE: "delete";
+    readonly MANAGE: "manage";
+    readonly VIEW: "view";
+    readonly EDIT: "edit";
+    readonly PUBLISH: "publish";
+    readonly ARCHIVE: "archive";
+    readonly APPROVE: "approve";
+    readonly REJECT: "reject";
+};
+/**
+ * Helper to create subject types
+ */
+export declare const subject: (type: string, data?: object) => object;
+/**
+ * Check if subject is of specific type
+ */
+export declare const subjectType: (subject: any) => string;

package/lib/components/Can/builder.d.ts

@@ -0,0 +1,113 @@
+import { AbilityCore } from './ability';
+import { PermissionRule } from './types';
+/**
+ * Fluent API for building permissions
+ */
+export declare class PermissionBuilder {
+    private rules;
+    /**
+     * Grant permission
+     */
+    allow(action: string, subject?: any, field?: string): this;
+    /**
+     * Deny permission
+     */
+    forbid(action: string, subject?: any, field?: string): this;
+    /**
+     * Conditional permission
+     */
+    allowIf(action: string, subject?: any, conditions?: Record<string, any>, field?: string): this;
+    /**
+     * Conditional denial
+     */
+    forbidIf(action: string, subject?: any, conditions?: Record<string, any>, field?: string): this;
+    /**
+     * Grant all actions on a subject
+     */
+    manage(subject: any): this;
+    /**
+     * Forbid all actions on a subject
+     */
+    forbidAll(subject: any): this;
+    /**
+     * Role-based permissions
+     */
+    role(roleName: string, callback: (role: RoleBuilder) => void): this;
+    /**
+     * Build the ability with all rules
+     */
+    build(): AbilityCore;
+    /**
+     * Get all rules
+     */
+    getRules(): PermissionRule[];
+    /**
+     * Clear all rules
+     */
+    clear(): this;
+    /**
+     * Merge rules from another builder
+     */
+    merge(other: PermissionBuilder): this;
+}
+/**
+ * Role-specific permission builder
+ */
+export declare class RoleBuilder {
+    private roleName;
+    private rules;
+    constructor(roleName: string);
+    /**
+     * Grant permission for this role
+     */
+    can(action: string, subject?: any, field?: string): this;
+    /**
+     * Deny permission for this role
+     */
+    cannot(action: string, subject?: any, field?: string): this;
+    /**
+     * Manage all actions on subject for this role
+     */
+    manage(subject: any): this;
+    /**
+     * Get all rules for this role
+     */
+    getRules(): PermissionRule[];
+}
+/**
+ * Common permission patterns
+ */
+export declare class PermissionPatterns {
+    /**
+     * Admin permissions - can do everything
+     */
+    static admin(): PermissionBuilder;
+    /**
+     * User permissions - basic CRUD on own resources
+     */
+    static user(userId: string): PermissionBuilder;
+    /**
+     * Guest permissions - read-only public content
+     */
+    static guest(): PermissionBuilder;
+    /**
+     * Moderator permissions - manage content but not users
+     */
+    static moderator(): PermissionBuilder;
+    /**
+     * Owner permissions - full control over owned resources
+     */
+    static owner(ownerId: string): PermissionBuilder;
+}
+/**
+ * Helper function to create a new permission builder
+ */
+export declare function permissions(): PermissionBuilder;
+/**
+ * Helper function to create ability from rules array
+ */
+export declare function defineAbility(callback: (builder: PermissionBuilder) => void): AbilityCore;
+/**
+ * Helper function to create common role-based abilities
+ */
+export declare function defineRoleAbility(role: string, callback: (role: RoleBuilder) => void): AbilityCore;

package/lib/components/Can/context.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { PermissionProviderProps, PermissionContextValue } from './types';
+/**
+ * Permission Provider Component
+ */
+export declare const PermissionProvider: React.FC<PermissionProviderProps>;
+/**
+ * Hook to access permission context
+ */
+export declare const usePermissions: (options?: {
+    required?: boolean;
+    debug?: boolean;
+}) => PermissionContextValue;
+/**
+ * Hook to check a specific permission
+ */
+export declare const useCan: (action: string, subject: any, field?: string) => boolean;
+/**
+ * Hook to check if permission is denied
+ */
+export declare const useCannot: (action: string, subject: any, field?: string) => boolean;
+/**
+ * Hook to get the current ability instance
+ */
+export declare const useAbility: () => import("./types").Ability;

package/lib/components/Can/index.d.ts

@@ -0,0 +1,6 @@
+export { Can, CanWithConditions, Cannot, PermissionGate, withCan, withCannot } from './Can';
+export { PermissionProvider, usePermissions, useAbility } from './context';
+export { AbilityCore } from './ability';
+export { PermissionBuilder, RoleBuilder, PermissionPatterns, permissions, defineAbility, defineRoleAbility } from './builder';
+export type { Action, Subject, Field, Conditions, PermissionRule, PermissionCheck, Ability, CanProps, CanWithConditionsProps, CannotProps, PermissionGateProps, PermissionContextValue, PermissionProviderProps, UsePermissionsOptions } from './types';
+export { AbilityCore as PermissionAbility } from './ability';

package/lib/components/Can/types.d.ts

@@ -0,0 +1,228 @@
+import React from 'react';
+import { ViewStyle } from 'react-native';
+/**
+ * Possible permission actions
+ */
+export type Action = string;
+/**
+ * Subject type - can be string, class, or object
+ */
+export type Subject = string | Function | object;
+/**
+ * Field within a subject
+ */
+export type Field = string;
+/**
+ * Conditions for permissions (for object-level permissions)
+ */
+export type Conditions = Record<string, any>;
+/**
+ * Permission rule definition
+ */
+export interface PermissionRule {
+    /** Action being performed */
+    action: Action | Action[];
+    /** Subject being acted upon */
+    subject: Subject | Subject[];
+    /** Fields within the subject (optional) */
+    fields?: Field[];
+    /** Conditions that must be met (optional) */
+    conditions?: Conditions;
+    /** Whether this rule grants or denies permission */
+    inverted?: boolean;
+    /** Human-readable reason for the rule */
+    reason?: string;
+}
+/**
+ * Permission check result
+ */
+export interface PermissionCheck {
+    /** Whether permission is granted */
+    allowed: boolean;
+    /** Reason for the decision */
+    reason?: string;
+    /** Matched rule */
+    rule?: PermissionRule;
+}
+/**
+ * Ability interface for checking permissions
+ */
+export interface Ability {
+    /** Check if action is allowed on subject */
+    can(action: Action, subject: Subject, field?: Field): boolean;
+    /** Check if action is forbidden on subject */
+    cannot(action: Action, subject: Subject, field?: Field): boolean;
+    /** Get detailed permission check result */
+    check(action: Action, subject: Subject, field?: Field): PermissionCheck;
+    /** Update ability rules */
+    update(rules: PermissionRule[]): void;
+    /** Get all current rules */
+    getRules(): PermissionRule[];
+    /** Clear all rules */
+    clear(): void;
+}
+/**
+ * Can component props for basic usage
+ */
+export interface CanProps {
+    /** Action to check */
+    I: Action;
+    /** Subject to check against */
+    a?: Subject;
+    /** Specific field to check (optional) */
+    field?: Field;
+    /** Children to render when permission is granted */
+    children?: React.ReactNode;
+    /** Alternative content when permission is denied */
+    fallback?: React.ReactNode;
+    /** Custom ability instance (optional) */
+    ability?: Ability;
+    /** Additional styles */
+    style?: ViewStyle;
+    /** Test ID for testing */
+    testID?: string;
+    /** Whether to passthrough (render children regardless) for development */
+    passthrough?: boolean;
+}
+/**
+ * Enhanced Can component props with conditions
+ */
+export interface CanWithConditionsProps extends Omit<CanProps, 'a'> {
+    /** Subject instance with data for condition checking */
+    this: object;
+}
+/**
+ * Cannot component props (inverse of Can)
+ */
+export interface CannotProps extends CanProps {
+}
+/**
+ * Permission gate props for route-level protection
+ */
+export interface PermissionGateProps {
+    /** Required permissions (all must pass) */
+    permissions: Array<{
+        action: Action;
+        subject: Subject;
+        field?: Field;
+    }>;
+    /** Children to render when all permissions pass */
+    children: React.ReactNode;
+    /** Fallback when permissions fail */
+    fallback?: React.ReactNode;
+    /** Custom ability instance */
+    ability?: Ability;
+    /** Redirect function for navigation-based fallbacks */
+    onUnauthorized?: () => void;
+}
+/**
+ * Permission context value
+ */
+export interface PermissionContextValue {
+    /** Current ability instance */
+    ability: Ability;
+    /** Update ability rules */
+    updateAbility: (rules: PermissionRule[]) => void;
+    /** Check if user can perform action */
+    can: (action: Action, subject: Subject, field?: Field) => boolean;
+    /** Check if user cannot perform action */
+    cannot: (action: Action, subject: Subject, field?: Field) => boolean;
+    /** Get current user context */
+    user?: any;
+    /** Update user context */
+    setUser?: (user: any) => void;
+}
+/**
+ * Permission provider props
+ */
+export interface PermissionProviderProps {
+    /** Initial permission rules */
+    rules?: PermissionRule[];
+    /** Initial user context */
+    user?: any;
+    /** Children components */
+    children: React.ReactNode;
+    /** Development mode settings */
+    dev?: {
+        /** Log permission checks */
+        logChecks?: boolean;
+        /** Warn about missing permissions */
+        warnMissing?: boolean;
+        /** Allow passthrough in development */
+        allowPassthrough?: boolean;
+    };
+}
+/**
+ * Hook options for usePermissions
+ */
+export interface UsePermissionsOptions {
+    /** Whether to log permission checks */
+    debug?: boolean;
+    /** Throw error if no ability found */
+    required?: boolean;
+}
+/**
+ * Permission definition for bulk operations
+ */
+export interface PermissionDefinition {
+    /** Actions for this resource */
+    actions: Action[];
+    /** Subject type */
+    subject: Subject;
+    /** Default conditions */
+    conditions?: Conditions;
+    /** Description */
+    description?: string;
+}
+/**
+ * Role-based permission set
+ */
+export interface RolePermissions {
+    /** Role name */
+    role: string;
+    /** Permission rules for this role */
+    rules: PermissionRule[];
+    /** Description of the role */
+    description?: string;
+    /** Whether role is active */
+    active?: boolean;
+}
+/**
+ * Permission builder for fluent API
+ */
+export interface PermissionBuilder {
+    /** Add a permission rule */
+    allow(action: Action | Action[]): PermissionSubjectBuilder;
+    /** Add a denial rule */
+    deny(action: Action | Action[]): PermissionSubjectBuilder;
+    /** Build the rules array */
+    build(): PermissionRule[];
+}
+export interface PermissionSubjectBuilder {
+    /** Specify the subject */
+    on(subject: Subject | Subject[]): PermissionFieldBuilder;
+}
+export interface PermissionFieldBuilder {
+    /** Specify fields (optional) */
+    fields(fields: Field[]): PermissionConditionBuilder;
+    /** Specify conditions */
+    when(conditions: Conditions): PermissionRuleBuilder;
+    /** Add reason */
+    because(reason: string): PermissionRuleBuilder;
+    /** Finish building this rule */
+    build(): PermissionRule;
+}
+export interface PermissionConditionBuilder {
+    /** Specify conditions */
+    when(conditions: Conditions): PermissionRuleBuilder;
+    /** Add reason */
+    because(reason: string): PermissionRuleBuilder;
+    /** Finish building this rule */
+    build(): PermissionRule;
+}
+export interface PermissionRuleBuilder {
+    /** Add reason */
+    because(reason: string): PermissionRuleBuilder;
+    /** Finish building this rule */
+    build(): PermissionRule;
+}

package/lib/components/Card/Card.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { CardProps } from './types';
+export declare const Card: React.FC<CardProps>;

package/lib/components/Card/index.d.ts

@@ -0,0 +1,2 @@
+export { Card } from './Card';
+export type { CardProps } from './types';

package/lib/components/Card/types.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { PlatformBlocksTheme } from '../../core/theme';
+import { SpacingProps, LayoutProps } from '../../core/utils';
+import { BorderRadiusProps } from '../../core/theme/radius';
+import { ShadowProps } from '../../core/theme/shadow';
+export interface CardProps extends SpacingProps, LayoutProps, BorderRadiusProps, ShadowProps {
+    children?: React.ReactNode;
+    variant?: 'outline' | 'filled';
+    padding?: number;
+    style?: any;
+    onPress?: () => void;
+    disabled?: boolean;
+    onContextMenu?: (e: any) => void;
+}
+export type { PlatformBlocksTheme };

package/lib/components/Carousel/Carousel.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { CarouselProps } from './types';
+export declare const Carousel: React.FC<CarouselProps>;
+export default Carousel;

package/lib/components/Carousel/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Carousel } from './Carousel';
+export type { CarouselProps } from './types';