forclan / core-types-ts

core-types ⬌ TypeScript interface conversion

core-types-ts

This package provides conversion functions between core-types and TypeScript.

You probably don't want to use this package directly, but rather typeconv which uses this package to convert between TypeScript, JSON Schema and GraphQL.

See

Other conversion packages:

• core-types-json-schema
• core-types-graphql
• core-types-suretype (which is also using this package)

Contents

• Usage
  • core-types to TypeScript
  • TypeScript to core-types

Usage

There are two conversion functions, convertCoreTypesToTypeScript and convertTypeScriptToCoreTypes, both returning a wrapped value, of the type ConversionResult.

core-types to TypeScript

import { convertCoreTypesToTypeScript } from 'core-types-ts'

let doc; // This core-types document comes from somewhere

const { data: tsSourceCode } = convertCoreTypesToTypeScript( doc );

You can provide options as a second argument fn the type:

interface ToTsOptions
{
	warn?: WarnFunction;
	filename?: string;
	sourceFilename?: string;
	useUnknown?: boolean;
	declaration?: boolean;
	userPackage?: string;
	userPackageUrl?: string;
	noDisableLintHeader?: boolean;
	noDescriptiveHeader?: boolean;
	unsupported?: 'ignore' | 'warn' | 'error';
}

These options are all optional.

• warn: A function callback to be used for warnings, defaults to console.warn.
• filename The filename to be written to.
  This is a hint, no file will be written by the conversion function.
• sourceFilename: The name of the source file from which the core-types comes.
• useUnknown: Use unknown rather than any for any-types.
• declaration: Write a declaration file, where e.g. "export interface" becomes "export declare interface".
• userPackage: The name of the package using this package.
• userPackageUrl: The url to the package using this package.
• noDisableLintHeader: Prevent writing the "disable linting" comment.
• noDescriptiveHeader: Do no write a top-level descriptive comment about the auto-generated file
• unsupported: What to do when detecting an unsupported type
  • ignore: Ignore (skip) type
  • warn: Ignore type, but warn (default)
  • error: Throw an error

The warn function is of type WarnFunction from core-types, meaning it takes a message as string, and an optional second argument of type CoreTypesErrorMeta, also from core-types.

TypeScript to core-types

import { convertTypeScriptToCoreTypes } from 'core-types-ts'

let sourceCode; // This source code comes from somewhere

const { data: doc } = convertTypeScriptToCoreTypes( sourceCode );

An optional second argument can be provided on the form

interface FromTsOptions
{
	warn?: WarnFunction;
	nonExported?: 'fail' | 'ignore' | 'include' | 'inline' | 'include-if-referenced';
	unsupported?: 'ignore' | 'warn' | 'error';
}

• warn: The same warn function as in CoreTypesToGraphqlOptions
• nonExported: How to handle references to non-exported types
  • fail: Fail conversion with an Error
  • ignore: Don't include non-exported types, but allow references to them
  • include: Include non-exported types
  • inline: Don't include non-exported types, inline them if necessary.
    Will throw an Error if the inlined types have cyclic dependencies.
  • include-if-referenced: Include non-exported types only if they are referenced
    from exported types (default)
• unsupported: What to do when detecting an unsupported type
  • ignore: Ignore (skip) type (default)
  • warn: Ignore type, but warn
  • error: Throw an error