@platform-blocks/ui 0.5.0 → 0.6.0

package/lib/index.d.ts

@@ -95,20 +95,15 @@ export { Skeleton } from './components/Skeleton';
 export { Loader } from './components/Loader';
 export { Gauge } from './components/Gauge';
 export { Ring } from './components/Ring';
-export { NavigationProgress, navigationProgress } from './components/NavigationProgress';
 export { Toast, ToastProvider, useToast, useToastApi, onToastsRequested } from './components/Toast';
 export { Dialog, DialogProvider, DialogRenderer, useDialog, useDialogApi, useDialogs, useSimpleDialog, onDialogsRequested } from './components/Dialog';
 export { Tooltip } from './components/Tooltip';
 export { Overlay } from './components/Overlay';
 export { LoadingOverlay } from './components/LoadingOverlay';
-export { HoverCard } from './components/HoverCard';
 export { ContextMenu } from './components/ContextMenu';
 export { Popover } from './components/Popover';
 export { Spotlight, SpotlightProvider, useSpotlightStore, spotlight, createSpotlightStore, useSpotlightStoreInstance, useDirectSpotlightState, directSpotlight, onSpotlightRequested } from './components/Spotlight';
 export { FloatingActions } from './components/FloatingActions';
-export { Can, CanWithConditions, Cannot, PermissionGate, withCan, withCannot } from './components/Can';
-export { PermissionProvider, usePermissions, useAbility } from './components/Can';
-export { AbilityCore, PermissionBuilder, RoleBuilder, PermissionPatterns, permissions, defineAbility, defineRoleAbility } from './components/Can';
 export { Icon } from './components';
 export { IconButton } from './components/IconButton';
 export { Image } from './components/Image';
@@ -206,11 +201,9 @@ export type { RingProps, RingColorStop, RingRenderContext } from './components/R
 export type { ToastProps } from './components/Toast';
 export type { DialogProps, DialogConfig, UseSimpleDialogOptions } from './components/Dialog';
 export type { TooltipProps } from './components/Tooltip';
-export type { HoverCardProps } from './components/HoverCard';
 export type { ContextMenuProps } from './components/ContextMenu';
 export type { PopoverProps, PopoverTargetProps, PopoverDropdownProps } from './components/Popover';
 export type { SpotlightProps } from './components/Spotlight';
-export type { Action, Subject, Field, Conditions, PermissionRule, PermissionCheck, Ability, CanProps, CanWithConditionsProps, CannotProps, PermissionGateProps, PermissionContextValue, PermissionProviderProps, UsePermissionsOptions } from './components/Can';
 export type { BrandIconProps, BrandName } from './components/BrandIcon';
 export type { CollapseProps } from './components/Collapse';
 export type { IconButtonProps } from './components/IconButton';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platform-blocks/ui",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "A React Native UI library",
   "type": "module",
   "main": "lib/cjs/index.js",

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

@@ -1,30 +0,0 @@
-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

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

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

@@ -1,89 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,230 +0,0 @@
-import React from 'react';
-import { ViewStyle } from 'react-native';
-/**
- * Possible permission actions
- */
-export type Action = string;
-/**
- * Subject type - can be string, class, or object
- */
-type SubjectClass = abstract new (...args: any[]) => unknown;
-type SubjectObject = Record<string, unknown> | object;
-export type Subject = string | SubjectClass | SubjectObject;
-/**
- * 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: Subject;
-}
-/**
- * Cannot component props (inverse of Can)
- */
-export type CannotProps = 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;
-}
-export {};

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

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

package/lib/components/NavigationProgress/NavigationProgress.d.ts

@@ -1,4 +0,0 @@
-import React from 'react';
-import type { NavigationProgressProps, NavigationProgressController } from './types';
-export declare const navigationProgress: NavigationProgressController;
-export declare const NavigationProgress: React.FC<NavigationProgressProps>;

package/lib/components/NavigationProgress/defaults.d.ts

@@ -1,8 +0,0 @@
-export declare const NAVIGATIONPROGRESS_DEFAULTS: {
-    readonly size: 3;
-    readonly color: "primary";
-    readonly zIndex: 9999;
-    readonly overlay: true;
-    readonly stepInterval: 500;
-    readonly radius: 0;
-};

package/lib/components/NavigationProgress/hooks/useNavigationProgressState.d.ts

@@ -1 +0,0 @@
-export declare function useNavigationProgressState(): {};

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

@@ -1,2 +0,0 @@
-export { NavigationProgress, navigationProgress } from './NavigationProgress';
-export type { NavigationProgressProps, NavigationProgressController } from './types';

package/lib/components/NavigationProgress/styles/resolver.d.ts

@@ -1 +0,0 @@
-export declare function getNavigationProgressStyles(): {};

package/lib/components/NavigationProgress/tokens.d.ts

@@ -1,4 +0,0 @@
-export declare const NavigationProgressTokens: {
-    variant: {};
-    size: {};
-};

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

@@ -1,30 +0,0 @@
-export interface NavigationProgressProps {
-    /** Controlled progress value (0-100). If omitted, internal controller progress is used */
-    value?: number;
-    /** Height (px) */
-    size?: number;
-    /** Color token key or raw color */
-    color?: string;
-    /** Whether bar is active/visible when value is controlled */
-    active?: boolean;
-    /** z-index layering */
-    zIndex?: number;
-    /** If true position absolute at top full width */
-    overlay?: boolean;
-    /** Step interval in ms for internal progression animation */
-    stepInterval?: number;
-    /** Border radius */
-    radius?: number;
-    /** Custom styles */
-    style?: any;
-}
-export interface NavigationProgressController {
-    start: () => void;
-    stop: () => void;
-    complete: () => void;
-    reset: () => void;
-    set: (v: number) => void;
-    increment: (delta?: number) => void;
-    decrement: (delta?: number) => void;
-    isActive: () => boolean;
-}