@the-w1zard/types 1.0.1 → 1.0.2

package/src/index.ts

@@ -2493,17 +2493,7 @@ export interface AsyncSignalState<T> {
 export type ConflictPolicy2<T = any> = | ConflictPolicyName | ((current: T, incoming: T, meta: { key: string; timestamp: number }) => T)
 //export interface ConflictPolicy<T = any> { resolve?: (prev: T | undefined, next: T) => T | undefined; }
 export interface ConflictPolicy<T = any> { resolve?: (prev: T | undefined, next: T) => T | undefined; }
-export interface SignalOptions<T = any> {
-    schema?: SignalSchema<T>;
-    conflict?: ConflictPolicy<T>;
-    history?: { max: number };
-    lifecycle?: SignalLifecycle<T>;
-    persist?: boolean;
-    ttl?: number;
-    broadcast?: boolean;
-    trigger_render?: boolean;
-    conflictStrategy?: any
-}
+
 export interface SysEntry {
     read: () => any;
     write: (v: any) => void;
@@ -2550,15 +2540,7 @@ export interface AsyncSignalState<T = any> {
     retryCount: number;
     staleValue?: T;
 }
-export interface SignalOptions<T = any> {
-    schema?: SignalSchema<T>;
-    conflict?: ConflictPolicy<T>;
-    history?: { max: number };
-    lifecycle?: SignalLifecycle<T>;
-    persist?: boolean;
-    ttl?: number;
-    broadcast?: boolean;
-}
+
 export interface SignalTimelineEntry {
     value: any;
     timestamp: number;

package/src/mimic.d.ts

@@ -0,0 +1,53 @@
+export {} 
+
+
+declare global {
+    type AnyFn = (...args: any[]) => any;
+    type AnyRecord = Record<PropertyKey, any>;
+    type UnwrapFactory<C> = C extends (...args: any[]) => infer O ? O : C;
+    type IsAny<T> = 0 extends 1 & T ? true : false;
+    type NodeVariants<Node> = Node extends {variants: infer V} ? V : Node extends {__V__?: infer V} ? V : {};
+    type NodeSlots<Node> = Node extends {slots: infer S} ? S : Node extends {__S__?: infer S} ? S : never;
+    type NodeTypes<Node> = Node extends {types: infer T} ? T : Node extends {__T__?: infer T} ? T : unknown;
+    type NodeInterfaces<Node> = Node extends {interfaces: infer I} ? I : Node extends {interface: infer I} ? I : Node extends {__I__?: infer I} ? I : unknown;
+    type NodeEnums<Node> = Node extends {enums: infer E} ? E : Node extends {enum: infer E} ? E : Node extends {__E__?: infer E} ? E : unknown;
+    type NodeConstants<Node> = Node extends {constants: infer C} ? C : Node extends {__C__?: infer C} ? C : unknown;
+    type NodeSpecs<Node> = Node extends {specs: infer SP} ? SP : Node extends {__SP__?: infer SP} ? SP : unknown;
+    type NodeSource<Node> = Node extends {source: infer SO} ? SO : Node extends {__SO__?: infer SO} ? SO : unknown;
+    type NodeCloud<Node> = Node extends {cloud: infer CL} ? CL : Node extends {__CL__?: infer CL} ? CL : unknown;
+    type NodeGenerics<Node> = Node extends {generics: infer G} ? G : Node extends {__G__?: infer G} ? G : unknown;
+    type StringKey<T> = Extract<keyof T, string>;
+    type VariantKeys<V> = {[K in keyof V]: V[K] extends object ? StringKey<V[K]> : never};
+    type VariantPropsFrom<V> = IsAny<V> extends true ? Record<string, any> : V extends Record<string, object> ? {[K in keyof V]?: StringKey<V[K]> | null} : {};
+    type SlotNames<S> = S extends Record<string, unknown> ? StringKey<S> : never;
+    type SlotClasses<S> = S extends Record<string, unknown> ? Partial<Record<SlotNames<S>, ClassInput>> : Record<string, ClassInput>;
+    type ExposedVariantGroup<V> = V extends Record<string, ClassInput> ? V & {extend(overrides: Partial<V>): V} : V;
+    type ExposedVariantMap<V> = V extends Record<string, object> ? {[K in keyof V]: ExposedVariantGroup<V[K]>} : {};
+    type VariantCallProps<Node> = VariantPropsFrom<NodeVariants<Node>> & NodeTypes<Node> & {animation?: string; preset?: string; class?: ClassInput; className?: ClassInput; __instanceId__?: string; freyr?: any};
+    type SlotCallProps<Node> = VariantPropsFrom<NodeVariants<Node>> & {preset?: string; class?: SlotClasses<NodeSlots<Node>>; className?: SlotClasses<NodeSlots<Node>>; __instanceId__?: string; freyr?: any};
+    type SlotResult<Node> = NodeSlots<Node> extends infer S ? (S extends Record<string, unknown> ? {[K in keyof S]: (extra?: ClassInput) => string} : {}) : {};
+    
+    type InferNodeReturn<Node> = string & {
+        slots: (props?: SlotCallProps<Node>) => SlotResult<Node>;
+        variants: ExposedVariantMap<NodeVariants<Node>>;
+        types: NodeTypes<Node>;
+        interfaces: NodeInterfaces<Node>;
+        enums: NodeEnums<Node>;
+        interface: NodeInterfaces<Node>;
+        enum: NodeEnums<Node>;
+        constants: NodeConstants<Node>;
+        specs: NodeSpecs<Node>;
+        source: NodeSource<Node>;
+        cloud: NodeCloud<Node>;
+        generics: NodeGenerics<Node>;
+        extend: (overrides: Partial<Node>) => InferNodeReturn<Node>;
+    } & VariantPropsFrom<NodeVariants<Node>>;
+    
+    type InferNode<Node> = Node extends AnyFn ? (ReturnType<Node> extends infer Produced ? InferNodeReturn<Produced> : never) : InferNodeReturn<Node>;
+    
+      type IncantationsMimic<C> = UnwrapFactory<C> extends infer Produced ? Produced extends Record<string, any> ? { [K in keyof Produced]: InferNode<Produced[K]>; } & { incan_types: AllIncantationTypes; freyr: any; } : Record<string, any> : Record<string, any>;
+    
+      type IncantationsMimicFactory<C> = C extends (...args: any[]) => any ? IncantationsMimic<C> : IncantationsMimic<C>;
+      type IncantationsMimicProps<C> = UnwrapFactory<C> extends Record<string, infer Node> ? VariantCallProps<Node> : Record<string, any>;
+    
+}

package/src/mirror_image.d.ts

@@ -0,0 +1,147 @@
+export {}
+
+declare global {
+    
+  type MirrorImageAnyRecord = Record<PropertyKey, any>;
+  
+  type AnyFunction = (...args: any[]) => any;
+  
+  type MirrorImageUnwrapFactory<C> = C extends (...args: any[]) => infer Output ? Output : C;
+  
+  type MirrorImageIsAny<T> = 0 extends 1 & T ? true : false;
+  type MirrorImageStringKey<T> = Extract<keyof T, string>;
+  
+  
+  export type MirrorImageVariantKeys<V> = {[K in keyof V]: V[K] extends object ? MirrorImageStringKey<V[K]> : never};
+  
+  export type MirrorImageVariantPropsFrom<V> = MirrorImageIsAny<V> extends true ? MirrorImageAnyRecord : V extends Record<string, object> ? {[K in keyof V]?: MirrorImageStringKey<V[K]> | null} : {};
+  
+  type MirrorImageNodeVariants<Node> = Node extends {variants: infer V} ? V : Node extends {__V__?: infer V} ? V : {};
+  
+  type MirrorImageNodeSlots<Node> = Node extends {slots: infer S} ? S : Node extends {__S__?: infer S} ? S : never;
+  
+  type MirrorImageNodeTypes<Node> = Node extends {types: infer T} ? T : Node extends {__T__?: infer T} ? T : unknown;
+  
+  type MirrorImageNodeInterfaces<Node> = Node extends {interfaces: infer I} ? I : Node extends {interface: infer I} ? I : Node extends {__I__?: infer I} ? I : unknown;
+  
+  type MirrorImageNodeEnums<Node> = Node extends {enums: infer E} ? E : Node extends {enum: infer E} ? E : Node extends {__E__?: infer E} ? E : unknown;
+  
+  type MirrorImageNodeGenerics<Node> = Node extends {generics: infer G} ? G : Node extends {__G__?: infer G} ? G : unknown;
+  
+  type MirrorImageNodeConstants<Node> = Node extends {constants: infer C} ? C : Node extends {__C__?: infer C} ? C : unknown;
+  
+  type MirrorImageNodeSpecs<Node> = Node extends {specs: infer SP} ? SP : Node extends {__SP__?: infer SP} ? SP : unknown;
+  
+  type MirrorImageNodeSource<Node> = Node extends {source: infer SO} ? SO : Node extends {__SO__?: infer SO} ? SO : unknown;
+  
+  type MirrorImageNodeCloud<Node> = Node extends {cloud: infer CL} ? CL : Node extends {__CL__?: infer CL} ? CL : unknown;
+  
+  type NodeName<Node> = Node extends {__S__?: infer S extends string} ? S : never;
+  
+  type SlotsOf<Node> = MirrorImageNodeSlots<Node> extends Record<string, unknown> ? MirrorImageNodeSlots<Node> : {};
+  
+  type MirrorImageSlotNames<Node> = MirrorImageStringKey<SlotsOf<Node>>;
+  
+  type SlotClassProps<Node> = Partial<Record<MirrorImageSlotNames<Node>, ClassInput>>;
+  
+  type MirrorImageSlotResult<Node> = {[K in MirrorImageSlotNames<Node>]: (extra?: ClassInput) => string};
+  
+  type VariantGroup<V> = V extends Record<string, ClassInput> ? V & {extend(overrides: Record<string, ClassInput>): Record<string, ClassInput>} : V;
+  
+  type ExposedVariantGroups<V> = V extends Record<string, object> ? {[K in keyof V]: VariantGroup<V[K]>} : {};
+  
+  type NodeVariantProps<Node> = MirrorImageVariantPropsFrom<MirrorImageNodeVariants<Node>>;
+  
+  type CommonCallProps<Node> = NodeVariantProps<Node> & {animation?: string; preset?: string; class?: ClassInput; className?: ClassInput; __instanceId__?: string; freyr?: any; [key: string]: any;};
+  
+  type NodeCallable<Node> = (props?: CommonCallProps<Node> & MirrorImageNodeTypes<Node>) => string;
+  
+  type NodeSlotCallable<Node> = (props?: CommonCallProps<Node> & {class?: SlotClassProps<Node>; className?: SlotClassProps<Node>}) => MirrorImageSlotResult<Node>;
+  
+  type NodeDefinition<Node> = NodeCallable<Node> & {
+      __S__?: NodeName<Node>;
+      __V__?: MirrorImageNodeVariants<Node>;
+      __T__?: MirrorImageNodeTypes<Node>;
+      __I__?: MirrorImageNodeInterfaces<Node>;
+      __E__?: MirrorImageNodeEnums<Node>;
+      __G__?: MirrorImageNodeGenerics<Node>;
+      __C__?: MirrorImageNodeConstants<Node>;
+      __SP__?: MirrorImageNodeSpecs<Node>;
+      __SO__?: MirrorImageNodeSource<Node>;
+      __CL__?: MirrorImageNodeCloud<Node>;
+  
+      base?: ClassInput;
+      variants: ExposedVariantGroups<MirrorImageNodeVariants<Node>>;
+      slots: NodeSlotCallable<Node>;
+  
+      types: MirrorImageNodeTypes<Node>;
+      interfaces: MirrorImageNodeInterfaces<Node>;
+      enums: MirrorImageNodeEnums<Node>;
+      generics: MirrorImageNodeGenerics<Node>;
+      interface: MirrorImageNodeInterfaces<Node>;
+      enum: MirrorImageNodeEnums<Node>;
+  
+      constants: MirrorImageNodeConstants<Node>;
+      specs: MirrorImageNodeSpecs<Node>;
+      source: MirrorImageNodeSource<Node>;
+      cloud: MirrorImageNodeCloud<Node>;
+  
+      compoundVariants?: NodeName<Node> extends never ? CompoundVariant[] : SlotCompoundVariant[];
+  
+      defaultVariants?: {
+          [K in keyof MirrorImageNodeVariants<Node>]?: keyof MirrorImageNodeVariants<Node>[K];
+      };
+  
+      animation?: any;
+      transition?: any;
+      styles?: any;
+      inlineStyles?: any;
+      classNames?: any;
+      customTheme?: any;
+      customCSS?: any;
+  
+      as?: Record<string, ClassInput>;
+      docs?: any;
+      aliases?: any;
+  
+      stateMachine?: any;
+      logicMachine?: any;
+      useMachine?: any;
+      useTimeMachine?: any;
+      variantMachine?: any;
+  
+      context?: any;
+      useContext?: any;
+      createContext?: any;
+      sauronContext?: any;
+      reactContext?: any;
+      useReactContext?: any;
+      _compiledReactContext?: any;
+  
+      global?: any;
+      freyrClasses?: string;
+      freyrIncantations?: any;
+      __globalContent?: MirrorImageAnyRecord;
+      __isGlobalized__?: boolean;
+  
+      meta?: any;
+      staticMeta?: any;
+      __location?: any;
+      __definitionName?: string;
+  
+      extend(overrides: Partial<IncantationsConfig<any, any, any, any, any, any, any, any, any, any>>): NodeDefinition<Node>;
+  };
+  
+  type InferConsumerNode<Node> = Node extends AnyFunction ? (MirrorImageUnwrapFactory<Node> extends infer Produced ? NodeDefinition<Produced> : never) : NodeDefinition<Node>;
+  
+  type ConsumerObject<C> = MirrorImageUnwrapFactory<C> extends infer Produced ? (Produced extends MirrorImageAnyRecord ? Produced : {}) : {};
+  
+    type MirrorImage<C> = C extends AnyFunction ? {[K in keyof ConsumerObject<C>]: InferConsumerNode<ConsumerObject<C>[K]>} & {incan_types: AllIncantationTypes; freyr: any} : {[K in keyof ConsumerObject<C>]: InferConsumerNode<ConsumerObject<C>[K]>} & {incan_types: AllIncantationTypes; freyr: any};
+  
+    type MirrorImageTypeSurface = {[K in keyof AllIncantationTypes]: AllIncantationTypes[K]};
+  
+    type MirrorImageFactory<C> = MirrorImage<C>;
+  
+  
+  
+}

package/src/platform.d.ts

@@ -3777,19 +3777,6 @@ interface MIDDLEWARE_WIRE { matchesPattern(pattern: S, rt: S): B; }
 
 
 
- interface SignalOptions {
-    schema?: SignalSchema;
-    lifecycle?: SignalLifecycle;
-    conflict?: ConflictPolicy;
-    conflictStrategy?: ConflictStrategy;
-    triggerRender?: boolean;
-    history?: { max?: number };
-}
-
- type ConflictStrategy = "latest" | "fail" | "accumulate";
-
- type Boundary = "same-app" | "cross-app" | "isolated" | string;
-
  interface AtomWriteOptions {
     source?: string;
     cause?: string;
@@ -4171,17 +4158,7 @@ interface MIDDLEWARE_WIRE { matchesPattern(pattern: S, rt: S): B; }
         retryCount: N;
         staleValue?: T;
     }
-    interface SignalOptions {
-        schema?: SignalSchema;
-        conflict?: ConflictPolicy;
-        history?: { max: N };
-        lifecycle?: SignalLifecycle;
-        persist?: B;
-        ttl?: N;
-        broadcast?: B;
-        triggerRender?: B;
-        conflictStrategy?: "latest" | "fail" | "accumulate";
-    }
+
     interface SignalTimelineEntry {
         value: A;
         timestamp: N;
@@ -14962,17 +14939,7 @@ interface SLOT {
      type ConflictPolicy2<T = any> = | ConflictPolicyName | ((current: T, incoming: T, meta: { key: string; timestamp: number }) => T)
     // interface ConflictPolicy<T = any> { resolve?: (prev: T | undefined, next: T) => T | undefined; }
      interface ConflictPolicy<T = any> { resolve?: (prev: T | undefined, next: T) => T | undefined; }
-     interface SignalOptions<T = any> {
-        schema?: SignalSchema<T>;
-        conflict?: ConflictPolicy<T>;
-        history?: { max: number };
-        lifecycle?: SignalLifecycle<T>;
-        persist?: boolean;
-        ttl?: number;
-        broadcast?: boolean;
-        trigger_render?: boolean;
-        conflictStrategy?: any
-    }
+
      interface SysEntry {
         read: () => any;
         write: (v: any) => void;
@@ -15019,15 +14986,7 @@ interface SLOT {
         retryCount: number;
         staleValue?: T;
     }
-     interface SignalOptions<T = any> {
-        schema?: SignalSchema<T>;
-        conflict?: ConflictPolicy<T>;
-        history?: { max: number };
-        lifecycle?: SignalLifecycle<T>;
-        persist?: boolean;
-        ttl?: number;
-        broadcast?: boolean;
-    }
+
      interface SignalTimelineEntry {
         value: any;
         timestamp: number;