Module

TsBridge

Package
purescript-ts-bridge
Repository
thought2/purescript-ts-bridge

Re-exports from TsBridge.Class

#Tok Source

data Tok

Constructors

Instances

#TsBridge Source

class TsBridge (a :: Type)  where

Members

Instances

Re-exports from TsBridge.Cli

#mkTypeGenCli Source

mkTypeGenCli :: Either AppError TsProgram -> Effect Unit

Given a TsProgram returns an effectful CLI that can be used as an entry point for a type generator.

Re-exports from TsBridge.Core

#RecordDef Source

class RecordDef :: Type -> Row Type -> Constraintclass RecordDef tok r  where

Members

Instances

#RecordDefRL Source

class RecordDefRL :: Type -> Row Type -> RowList Type -> Constraintclass RecordDefRL tok r rl  where

Members

Instances

#TsBridgeBy Source

class TsBridgeBy tok a  where

Type Class that is used by the type generator to recursively traverse types. Instances for the specific types will be defined on the user's side with a typeclass like this:

class TsBridge a where
  tsBridge :: a -> StandaloneTsType

Then the internal type class is forwarded to the one of the user. For this you need to define a token data type and an instance like this:

data Tok = Tok

instance TsBridge a => TsBridgeBy Tok a where
  tsBridgeBy _ = tsBridge

The token will then be passed to all generic functions of the library.

Members

#tsValues Source

tsValues :: forall tok r. RecordDef tok r => tok -> Record r -> TsBridgeM (Array TsDeclaration)

#tsValue Source

tsValue :: forall tok a. TsBridgeBy tok a => tok -> String -> a -> TsBridgeM (Array TsDeclaration)

Exports a single PureScript value to TypeScript. tsValues may be better choice.

#tsTypeAliasesFromValues Source

tsTypeAliasesFromValues :: forall tok r. RecordDef tok r => tok -> Record r -> TsBridgeM (Array TsDeclaration)

#tsTypeAliasFromValue Source

tsTypeAliasFromValue :: forall tok a. TsBridgeBy tok a => tok -> String -> a -> TsBridgeM (Array TsDeclaration)

#tsTypeAlias Source

tsTypeAlias :: forall tok a. TsBridgeBy tok a => tok -> String -> Proxy a -> TsBridgeM (Array TsDeclaration)

For rare cases where you want to export a type alias. References to this type alias will be fully resolved in the generated code. So it is more practical to use a newtype instead, which can be references by name.

#tsOpaqueType Source

tsOpaqueType :: forall tok a. TsBridgeBy tok a => tok -> Proxy a -> TsBridgeM (Array TsDeclaration)

For rare cases where you want to manually export an opaque type. Once you export a value that contains a reference to this type, the type will be generated and exported automatically. Thus in most cases you don't need this.

Re-exports from TsBridge.DefaultImpls

#TypeVar Source

data TypeVar :: Symbol -> Typedata TypeVar (s :: Symbol)

Represents a monomorphized type variable. E.g. a Maybe a can become a Maybe (TypeVar "A"). It's useful to create some type aliases for variables that are used often, like: type A = TypeVar "A".

Constructors

#TsBridgeRecord Source

class TsBridgeRecord :: Type -> Row Type -> Constraintclass TsBridgeRecord tok r  where

Members

Instances

#TsBridgeRecordRL Source

class TsBridgeRecordRL :: Type -> RowList Type -> Constraintclass TsBridgeRecordRL tok rl  where

Members

Instances

#TsBridgeVariant Source

class TsBridgeVariant :: Type -> Row Type -> Constraintclass TsBridgeVariant tok r  where

Members

Instances

#TsBridgeVariantEncodedFlat Source

class TsBridgeVariantEncodedFlat :: Type -> Symbol -> Row Type -> Constraintclass TsBridgeVariantEncodedFlat tok symTag r  where

Members

Instances

#TsBridgeVariantEncodedFlatRL Source

class TsBridgeVariantEncodedFlatRL :: Type -> Symbol -> RowList Type -> Constraintclass TsBridgeVariantEncodedFlatRL tok symTag rl  where

Members

Instances

#TsBridgeVariantEncodedNested Source

class TsBridgeVariantEncodedNested :: Type -> Symbol -> Symbol -> Row Type -> Constraintclass TsBridgeVariantEncodedNested tok symTag symVal r  where

Members

Instances

#TsBridgeVariantEncodedNestedRL Source

class TsBridgeVariantEncodedNestedRL :: Type -> Symbol -> Symbol -> RowList Type -> Constraintclass TsBridgeVariantEncodedNestedRL tok symTag symVal rl  where

Members

Instances

#TsBridgeVariantRL Source

class TsBridgeVariantRL :: Type -> RowList Type -> Constraintclass TsBridgeVariantRL tok rl  where

Members

Instances

#tsBridgeUnit Source

tsBridgeUnit :: Proxy Unit -> TsBridgeM TsType

tsBridge type class method implementation for the Unit type

See this reference for details.

#tsBridgeUndefined Source

tsBridgeUndefined :: Proxy Undefined -> TsBridgeM TsType

tsBridge type class method implementation for the Undefined type.

#tsBridgeTypeVar Source

tsBridgeTypeVar :: forall s. IsSymbol s => Proxy (TypeVar s) -> TsBridgeM TsType

tsBridge type class method implementation for type variables. This is needed because polymorphic values cannot be exported directly. They have to be monomorphized: E.g. something of type Maybe a needs to be typed Maybe (Var "A") to be exported.

#tsBridgeTuple Source

tsBridgeTuple :: forall tok a b. TsBridgeBy tok a => TsBridgeBy tok b => tok -> Proxy (Tuple a b) -> TsBridgeM TsType

tsBridge type class method implementation for the Tuple type

See this reference for details.

#tsBridgeStringLit Source

tsBridgeStringLit :: forall sym. IsSymbol sym => Proxy (StringLit sym) -> TsBridgeM TsType

tsBridge type class method implementation for string literal types.

#tsBridgeString Source

tsBridgeString :: Proxy String -> TsBridgeM TsType

tsBridge type class method implementation for the String type

See this reference for details.

#tsBridgePromise Source

tsBridgePromise :: forall tok a. TsBridgeBy tok a => tok -> Proxy (Promise a) -> TsBridgeM TsType

tsBridge type class method implementation for the Promise type.

See this reference for details.

#tsBridgeOpaqueType Source

tsBridgeOpaqueType :: forall a. { moduleName :: String, typeArgs :: Array (String /\ (TsBridgeM TsType)), typeName :: String } -> Proxy a -> TsBridgeM TsType

tsBridge type class method implementation for opaque types

#tsBridgeOneOf Source

tsBridgeOneOf :: forall a b tok. TsBridgeBy tok a => TsBridgeBy tok b => tok -> Proxy (OneOf a b) -> TsBridgeM TsType

tsBridge type class method implementation for the OneOf type.

See this reference for details.

#tsBridgeObject Source

tsBridgeObject :: forall tok a. TsBridgeBy tok a => tok -> Proxy (Object a) -> TsBridgeM TsType

#tsBridgeNumber Source

tsBridgeNumber :: Proxy Number -> TsBridgeM TsType

tsBridge type class method implementation for the Number type.

See this reference for details.

#tsBridgeNullable Source

tsBridgeNullable :: forall a tok. TsBridgeBy tok a => tok -> Proxy (Nullable a) -> TsBridgeM TsType

tsBridge type class method implementation for the Nullable type.

See this reference for details.

#tsBridgeNewtype Source

tsBridgeNewtype :: forall tok a t. Newtype a t => TsBridgeBy tok t => tok -> { moduleName :: String, typeArgs :: Array (String /\ (TsBridgeM TsType)), typeName :: String } -> Proxy a -> TsBridgeM TsType

tsBridge type class method implementation for newtypes

#tsBridgeMaybe Source

tsBridgeMaybe :: forall tok a. TsBridgeBy tok a => tok -> Proxy (Maybe a) -> TsBridgeM TsType

tsBridge type class method implementation for the Maybe type

See this reference for details.

#tsBridgeInt Source

tsBridgeInt :: Proxy Int -> TsBridgeM TsType

tsBridge type class method implementation for the Int type

See this reference for details.

#tsBridgeFunction Source

tsBridgeFunction :: forall tok a b. TsBridgeBy tok a => TsBridgeBy tok b => tok -> Proxy (a -> b) -> TsBridgeM TsType

tsBridge type class method implementation for the a -> b (Function) type

See this reference for details.

#tsBridgeFn4 Source

tsBridgeFn4 :: forall tok a1 a2 a3 a4 b. TsBridgeBy tok a1 => TsBridgeBy tok a2 => TsBridgeBy tok a3 => TsBridgeBy tok a4 => TsBridgeBy tok b => tok -> Proxy (Fn4 a1 a2 a3 a4 b) -> TsBridgeM TsType

#tsBridgeFn3 Source

tsBridgeFn3 :: forall tok a1 a2 a3 b. TsBridgeBy tok a1 => TsBridgeBy tok a2 => TsBridgeBy tok a3 => TsBridgeBy tok b => tok -> Proxy (Fn3 a1 a2 a3 b) -> TsBridgeM TsType

#tsBridgeFn2 Source

tsBridgeFn2 :: forall tok a1 a2 b. TsBridgeBy tok a1 => TsBridgeBy tok a2 => TsBridgeBy tok b => tok -> Proxy (Fn2 a1 a2 b) -> TsBridgeM TsType

#tsBridgeEither Source

tsBridgeEither :: forall tok a b. TsBridgeBy tok a => TsBridgeBy tok b => tok -> Proxy (Either a b) -> TsBridgeM TsType

tsBridge type class method implementation for the Either type

See this reference for details.

#tsBridgeEffectFn4 Source

tsBridgeEffectFn4 :: forall tok a1 a2 a3 a4 b. TsBridgeBy tok a1 => TsBridgeBy tok a2 => TsBridgeBy tok a3 => TsBridgeBy tok a4 => TsBridgeBy tok b => tok -> Proxy (EffectFn4 a1 a2 a3 a4 b) -> TsBridgeM TsType

#tsBridgeEffectFn3 Source

tsBridgeEffectFn3 :: forall tok a1 a2 a3 b. TsBridgeBy tok a1 => TsBridgeBy tok a2 => TsBridgeBy tok a3 => TsBridgeBy tok b => tok -> Proxy (EffectFn3 a1 a2 a3 b) -> TsBridgeM TsType

#tsBridgeEffectFn2 Source

tsBridgeEffectFn2 :: forall tok a1 a2 b. TsBridgeBy tok a1 => TsBridgeBy tok a2 => TsBridgeBy tok b => tok -> Proxy (EffectFn2 a1 a2 b) -> TsBridgeM TsType

#tsBridgeEffectFn1 Source

tsBridgeEffectFn1 :: forall tok a1 b. TsBridgeBy tok a1 => TsBridgeBy tok b => tok -> Proxy (EffectFn1 a1 b) -> TsBridgeM TsType

#tsBridgeEffect Source

tsBridgeEffect :: forall tok a. TsBridgeBy tok a => tok -> Proxy (Effect a) -> TsBridgeM TsType

tsBridge type class method implementation for the Effect type

See this reference for details.

#tsBridgeChar Source

tsBridgeChar :: Proxy Char -> TsBridgeM TsType

tsBridge type class method implementation for the Char type

See this reference for details.

#tsBridgeBoolean Source

tsBridgeBoolean :: Proxy Boolean -> TsBridgeM TsType

tsBridge type class method implementation for the Boolean type

See this reference for details.

#tsBridgeArray Source

tsBridgeArray :: forall a tok. TsBridgeBy tok a => tok -> Proxy (Array a) -> TsBridgeM TsType

tsBridge type class method implementation for the Array type

See this reference for details.

Re-exports from TsBridge.Monad

#TsBridgeAccum Source

#Scope Source

newtype Scope

Constructors

Instances

#runTsBridgeM Source

Re-exports from TsBridge.Types

#PursModuleName Source

#Name Source

newtype Name

Instances

#CapError Source

class CapError :: (Type -> Type) -> Constraintclass (MonadError AppError m) <= CapError m 

#CapThrow Source

class CapThrow :: (Type -> Type) -> Constraintclass (MonadThrow AppError m) <= CapThrow m 

#unsafeName Source

#toTsName Source

#printName Source

#mkPursModuleName Source

#mkName Source

mkName :: forall m. MonadThrow AppError m => String -> m Name

#mapErr Source

mapErr :: forall e m a. MonadError e m => (e -> e) -> m a -> m a

Re-exports from TsBridge.Types.Intersection

#Intersection Source

data Intersection t0 t1

Instances

#ToTuples Source

class ToTuples a b | a -> b where

Members

Instances

#tsBridgeIntersection Source

tsBridgeIntersection :: forall a b tok. TsBridgeBy tok a => TsBridgeBy tok b => tok -> Proxy (Intersection a b) -> TsBridgeM TsType

#toTuple Source

toTuple :: forall a b. Intersection a b -> Tuple a b

#snd Source

snd :: forall a b. Intersection a b -> b

#fst Source

fst :: forall a b. Intersection a b -> a

#type (|&|) Source

Operator alias for TsBridge.Types.Intersection.Intersection (right-associative / precedence 7)

Re-exports from TsBridge.Types.TsRecord

#TsRecord Source

data TsRecord :: Row (ModField Type) -> Typedata TsRecord t0

Instances

#ModField Source

data ModField t0

#Mod Source

data Mod :: Row Boolean -> Type -> ModField Typedata Mod t0 t1

Instances

#Get Source

class Get :: Symbol -> Row (ModField Type) -> Type -> Constraintclass Get sym rts a | sym rts sym rts -> a where

Members

Instances

#GetKey Source

class GetKey :: forall k. Symbol -> Row k -> k -> k -> Constraintclass GetKey sym r fail match | sym r fail -> match

Instances

#GetKeyRL Source

class GetKeyRL :: forall k. Symbol -> RowList k -> k -> k -> Constraintclass GetKeyRL sym rl fail match | sym rl fail -> match

Instances

#GetMods Source

class GetMods :: Row Boolean -> Constraintclass GetMods r  where

Members

Instances

#GetModsRL Source

class GetModsRL :: RowList Boolean -> Constraintclass GetModsRL rl  where

Members

Instances

#ToRecord Source

class ToRecord :: Row (ModField Type) -> Row Type -> Constraintclass ToRecord rts r | rts -> r where

Members

Instances

#ToRecordBuilder Source

class ToRecordBuilder :: RowList (ModField Type) -> Row (ModField Type) -> Row Type -> Constraintclass ToRecordBuilder rl rts r | rl rts -> r where

Members

Instances

#TsBridgeTsRecord Source

class TsBridgeTsRecord :: Type -> Row (ModField Type) -> Constraintclass TsBridgeTsRecord tok r  where

Members

Instances

#TsBridgeTsRecordRL Source