@alinea/core

/**

Accumulate all entries of an AsyncGenerator into an array */

export function accumulate<T>(

gen: AsyncGenerator<T, any, unknown>

): Promise<Array<T>>

export namespace Auth {

export interface Server

{

router(): Router

}

export type View

= ComponentType<ViewProps>

export type ViewProps

{

setSession(

session: undefined | Session<Workspaces>

): void

}

/**

Configuration options for the dashboard */

export class Config<T extends Workspaces = Workspaces>

{

constructor<T extends Workspaces = Workspaces>(

options: ConfigOptions<T>

): Config<T>

options: ConfigOptions<T>

workspaces:

/**

Get the first workspace */

get defaultWorkspace(): Workspace<any>

/**

Get a root */

root(

workspace: string,

root: string

): Root<string>

/**

Find a type by workspace and name */

type(

workspace: string,

): undefined | Type<any>

}

/**

Configuration options */

export type ConfigOptions<T>

{

/**

The client side authentication view */

auth: Auth.View

/**

A record containing workspace configurations */

workspaces: T

}

/**

Create a new config instance */

export function createConfig<T extends Workspaces>(

options: ConfigOptions<T>

): Config<T>

export function createError(

code: number

): ErrorWithCode

export function createError(

code: ErrorCode

): ErrorWithCode

export function createError(

message: string

): ErrorWithCode

export function createError(

code: number,

message: string

): ErrorWithCode

export function createError(

code: ErrorCode,

message: string

): ErrorWithCode

/**

Create a ksuid */

export function createId(): string

export type DataOf<T>

= T extends Collection<infer U>

? U

: never

export function docFromEntry(

entry: Omit<Entry, "url" | "path" | "workspace" | "root" | "parent" | "parents" | "$status" | "$isContainer" | "i18n"> & {i18n: {id: string}} & {

[key extends string]: any

getType: {},

doc: Doc

): Doc

export namespace Entry {

export type Detail

{

draft:

| string

| undefined

entry: Entry

original:

| Entry

| null

parent: Entry.Minimal

previewToken: string

translations: Array<Entry.Minimal>

}

export type I18N

{

id: string

locale: string

parent:

| string

| undefined

parents: Array<string>

}

export type Minimal

= Pick<Entry,

| "id"

| "type"

| "title"

| "workspace"

| "root"

| "url"

| "parent"

| "i18n"

export type Raw

= Omit<Entry,

| "path"

| "workspace"

| "root"

| "url"

| "$status"

| "parent"

| "parents"

| "$isContainer"

| "i18n"

> &

{

i18n:

{

id: string

}

export type Summary

= Pick<Entry,

| "id"

| "type"

| "title"

| "workspace"

| "root"

| "url"

| "index"

| "parent"

| "i18n"

| "parents"

| "$isContainer"

> &

{

childrenCount: number

}

export interface Entry

{

$isContainer: boolean

$status: EntryStatus

i18n: I18N

id: string

index: string

parent:

| undefined

| string

parents: Array<string>

path: string

root: string

title: Label

type: string

url: string

workspace: string

}

export const Entry: Collection<Entry>

export function entryFromDoc(

doc: Doc,

getType: {}

): Entry

export type EntryOf<T>

= T extends Schema<infer U>

? U

: never

export enum EntryStatus

{

Archived

Draft

Published

Publishing

}

/**

export enum ErrorCode

{

AuthenticationTimeout

BadRequest

BandwidthLimitExceeded

Conflict

ExpectationFailed

Forbidden

Gone

I_am_a_Teapot

InsufficientStorage

InternalError

MethodNotAllowed

NotAcceptable

NotFound

NotImplemented

OutOfRange

PayloadTooLarge

PaymentRequired

ServiceUnavailable

Timeout

TooManyRequests

Unauthorized

UnprocessableEntity

UnsupportedMediaType

}

export class ErrorWithCode extends Error

{

constructor(

code: number

): ErrorWithCode

constructor(

code: ErrorCode

): ErrorWithCode

constructor(

message: string

): ErrorWithCode

constructor(

code: number,

message: string

): ErrorWithCode

constructor(

code: ErrorCode,

message: string

): ErrorWithCode

code: ErrorCode

message: string

stack: string

NotFound: ErrorWithCode

Unauthorized: ErrorWithCode

prepareStackTrace:

{}

stackTraceLimit: number

/**

Create .stack property on a target object */

captureStackTrace(

targetObject: object,

constructorOpt: Function

): void

}

export namespace Field {

export type List<T, Q = T>

= Field<Array<T>, ListMutator<T>, Q>

export type Record<T, Q = T>

= Field<T, RecordMutator<T>, Q>

export type Scalar<T, Q = T>

= Field<T,

{}

, Q>

export type Text<T, Q = T>

= Field<TextDoc<T>, RichTextMutator<T>, Q>

export function withView<V, M, Q, F extends Field<V, M, Q, F>, C extends {}>(

create: C,

view: FieldRenderer<V, M, F>

): C

}

export interface Field<V = any, M = any, Q = V>

{

label: Label

shape: Shape<V, M>

view: FieldRenderer<V, M, Field<V, M, Q>>

query<P>(

field: Expr<V>,

pages: Pages<P>

): undefined | Expr<Q>

}

export type FieldRenderer<V, M, F>

= ComponentType<

{

field: F

state: InputState<readonly [V, M]>

}

export function future<T>(

promise: Promise<T>

): Future<T>

export type Future<T = void>

= Promise<Outcome<T>>

export type HasType

{

type: string

}

export namespace Hub {

export type Context

{

user: User

}

export type DirEntry

{

path: string

stat: Stat

type:

| "file"

| "directory"

}

export type QueryOptions

{

/**

Query source data, not drafts */

source: boolean

}

export type Stat

{

lastModified: Date

size: number

}

export type Upload

{

averageColor: string

blurHash: string

buffer: ArrayBuffer

path: string

preview: string

}

export const routes:

{

draft(

id: string

): string

drafts(): string

entry(

id: string,

stateVector: Uint8Array

): string

files(

location: string

): string

publish(): string

query(): string

upload(): string

}

export interface Hub<T extends Workspaces = Workspaces>

{

config: Config<T>

deleteDraft(

id: string

): Future<boolean>

entry(

id: string,

stateVector: Uint8Array

): Future<null | Detail>

listDrafts(

workspace: string

): Future<Array<{id: string}>>

publishEntries(

entries: Array<Entry>

): Future<void>

query<T>(

cursor: Cursor<T>,

options: QueryOptions

): Future<Array<T>>

updateDraft(

id: string,

update: Uint8Array

): Future<void>

uploadFile(

workspace: string,

root: string,

file: Upload

): Future<File>

}

export type Id<T>

= string &

{

}

export function isError(

error: Error

): error is ErrorWithCode

export function isSeparator(

char: string

): boolean

export namespace Label {

export type Data

{

[language extends string]: string

}

export type Label

| string

| {$label: Label.Data}

export function Label(

data: Data

): {$label: Data}

export namespace Media {

export namespace File {

export type Preview

= Pick<File,

| "id"

| "workspace"

| "root"

| "title"

| "extension"

| "size"

| "preview"

| "averageColor"

| "blurHash"

}

export enum Type

{

File

Libary

}

export type File

= Entry &

{

averageColor: string

blurHash: string

extension: string

hash: string

height: number

location: string

preview: string

size: number

width: number

}

export type Library

= Entry

export const File: Collection<File>

export const Library: Collection<Entry>

export const imageExtensions: Array<string>

export function isImage(

path: string

): undefined | boolean | ""

}

export type Merge<T extends object>

= &

export const outcome:

{}

{

fails<Run extends OutcomeRunner>(

run: OutcomeRunner

): OutcomeResult<Run>

succeeds<Run extends OutcomeRunner>(

run: OutcomeRunner

): OutcomeResult<Run>

}

export namespace Outcome {

export class OutcomeImpl<T>

{

constructor<T>(

success: boolean

): OutcomeImpl<T>

success: boolean

isFailure(): this is FailureOutcome<T>

isSuccess(): this is SuccessOutcome<T>

map<U>(

fn: {}

): Outcome<U>

toJSON(): JSONRep<T>

}

export function Failure<T>(

error: any

): Outcome<T>

export function Success<T>(

data: T

): Outcome<T>

export function fromJSON<T>(

json: JSONRep<T>

): Outcome<T>

export function unpack<T>(

outcome: Outcome<T>

): T

}

export type Outcome<T = void>

= Outcome.OutcomeImpl<T> & Pair<T>

/**

Parse a ksuid into a Date of creation and a Buffer containing the random bits */

export function parseId(

str: string

): readonly [Date, Buffer]

export namespace Reference {

export type Entry

{

entry: string

id: string

type: "entry"

}

export type Url

{

id: string

type: "url"

url: string

}

export type Reference

| Reference.Entry

| Reference.Url

export function renderLabel(

label: Label

): string

export type RichTextMutator<R>

{

fragment: Y.XmlFragment

insert(

id: string,

block: string

): void

}

export class RichTextShape<T> implements Shape<TextDoc<T>, RichTextMutator<T>>

{

constructor<T>(

label: Label,

shapes: Record<string, RecordShape<T>>

): RichTextShape<T>

label: Label

shapes: Record<string, RecordShape<T>>

values: Record<string, RecordShape<T>>

create(): TextDoc<T>

fromY(

value: YMap<any>

): TextDoc<T>

mutator(

parent: YMap<any>,

key: string

): {fragment: any, insert: {}}

toY(

value: TextDoc<T>

): YMap<unknown>

typeOfChild<C>(

yValue: YMap<any>,

child: string

): Shape<C, any>

watch(

parent: YMap<any>,

key: string

): {}

}

export function root<T>(

label: Label,

options: RootOptions<T>

): RootConfig<T>

export class Root<T = string>

{

constructor<T = string>(

workspace: string,

config: RootConfig<T>

): Root<T>

label: Label

workspace: string

get contains(): Array<T>

get defaultLocale(): undefined | string

get i18n(): undefined | {locales: Array<string>}

get icon(): undefined | ComponentType<{}>

}

export const ROOT_KEY: "#root"

export type RootConfig<T = string>

{

label: Label

}

& RootOptions<T>

export type RootOptions<T = string>

{

contains: Array<T>

i18n:

{

locales: Array<string>

}

icon: ComponentType

}

/**

Create a schema, expects a string record of Type instances */

export function schema<Types extends LazyRecord<TypeConfig<any>>>(

types: Types

): SchemaConfig<TypeToEntry<TypeToRows<Types>>>

/**

Describes the different types of entries */

export class Schema<T = any> extends SchemaConfig<T>

{

constructor<T = any>(

workspace: Workspace<T>,

config: SchemaConfig<T>

): Schema<T>

shape: Record<string, RecordShape<any>>

typeMap: Map<string, Type<any>>

types: LazyRecord<TypeConfig<any>>

workspace: Workspace<T>

/**

Keys of every type */

get keys(): Array<string>

[iterator](): IterableIterator<[string, Type<any>]>

/**

A generic collection used to query any type in this schema */

collection(): Collection<T>

concat<X>(

that: SchemaConfig<X>

): SchemaConfig<T | X>

configEntries(): Array<[string, TypeConfig<any>]>

entries(): IterableIterator<[string, Type<any>]>

toSchema(

workspace: Workspace<T>

): Schema<T>

/**

Get a type by name */

type<K extends string>(

): undefined | Type<Extract<T, {type: K}>>

type(

): undefined | Type<any>

}

export class SchemaConfig<T = any>

{

constructor<T = any>(

types: LazyRecord<TypeConfig<any>>

): SchemaConfig<T>

shape: Record<string, RecordShape<any>>

types: LazyRecord<TypeConfig<any>>

concat<X>(

that: SchemaConfig<X>

): SchemaConfig<T | X>

configEntries(): Array<[string, TypeConfig<any>]>

toSchema(

workspace: Workspace<T>

): Schema<T>

}

export type Search

{

id: string

title: string

}

export const Search: Collection<Search>

export namespace Section {

export type Fields

= Lazy<

{

[key extends string]: any

}

{

id: never

root: never

type: never

workspace: never

}

export type FieldsOf<T>

= UnionToIntersection<InferFields<T>>

export type Input<T = any>

| Section<T>

| Presentational

| Fields

export function from<T>(

input: Input<T>

): Section<T>

export function withView<T extends Section<any, T>, Factory extends {}>(

create: Factory,

view: ComponentType<{section: T, state: InputState<any>}>

): Factory

}

export class Section<T = any>

{

constructor<T = any>(

fields: undefined | Fields,

view: ComponentType<{state: InputState<any>}>

): Section<T>

fields:

| undefined

| Fields

view: ComponentType<

{

state: InputState<any>

}

export interface Session<T extends Workspaces = Workspaces>

{

hub: Hub<T>

user: User

end(): Promise<void>

}

export namespace Shape {

export function List(

label: Label,

shapes: Record<string, RecordShape<any>>

): ListShape<any>

export function Record<T>(

label: Label,

shape: Record<string, Shape<any, any>>

): RecordShape<T>

export function RichText(

label: Label,

shapes: Record<string, RecordShape<any>>

): RichTextShape<any>

export function Scalar<T>(

label: Label

): ScalarShape<T>

}

export interface Shape<T = any, M = any>

{

label: Label

create(): T

fromY(

yValue: any

): T

mutator(

parent: YType,

key: string

): M

toY(

value: T

): any

typeOfChild<C>(

yValue: any,

child: string

): Shape<C, any>

watch(

parent: YType,

key: string

): {}

}

export function slugify(

input: string,

separator: string

): string

export type TextDoc<T>

= Array<TextNode<T>>

export namespace TextNode {

export type Element<T = any>

{

content: TextDoc<T>

type:

| "paragraph"

| "heading"

| "bold"

| "italic"

| "bulletList"

| "listItem"

| TypesOf<T>

}

export type Mark

{

attrs: Record<string, string>

type: string

}

export type Text

{

marks: Array<Mark>

text: string

type: "text"

}

export type TextNode<T = any>

| TextNode.Text

| TextNode.Element<T>

export namespace Tree {

export function children(

id: EV<string>,

depth: number

): Cursor<Entry>

export function nextSibling(

id: EV<string>

): CursorSingleRow<Entry>

export function parent(

id: EV<string>

): Cursor<Entry>

export function parents(

id: EV<string>

): Cursor<Entry>

export function prevSibling(

id: EV<string>

): CursorSingleRow<Entry>

export function siblings(

id: EV<string>

): Cursor<Entry>

}

/**

Create a new type */

export function type<T extends Array<Input<any>>>(

label: Label,

sections: T

): TypeConfig<Section.FieldsOf<T[number]>>

/**

Describes the structure of an entry by their fields and type */

export class Type<T = any> extends TypeConfig<T>

{

constructor<T = any>(

schema: Schema<any>,

config: TypeConfig<T>

): Type<T>

fields: Record<string, Field<any, any, any>>

label: Label

options: TypeOptions<T>

schema: Schema<any>

sections: Array<Section<any>>

shape: RecordShape<T>

get isContainer(): boolean

[iterator](): IterableIterator<[string, Field<any, any, any>]>

collection(): Collection<T>

configure(

options: TypeOptions<T>

): TypeConfig<T>

/**

Create a new Entry instance of this type */

create(): Entry & T

/**

Create a new empty instance of this type's fields */

empty(): T

/**

Get a field by name */

field(

key: string

): Field<any, any, any>

selection(

cursor: Cursor<T>,

pages: Pages<any>

): undefined | Selection<T>

toType(

schema: Schema<any>,

): Type<T>

}

export class TypeConfig<T = any>

{

constructor<T = any>(

label: Label,

sections: Array<Section<any>>,

options: TypeOptions<T>

): TypeConfig<T>

fields: Record<string, Field<any, any, any>>

label: Label

options: TypeOptions<T>

sections: Array<Section<any>>

shape: RecordShape<T>

get isContainer(): boolean

[iterator](): IterableIterator<[string, Field<any, any, any>]>

configure(

options: TypeOptions<T>

): TypeConfig<T>

/**

Create a new empty instance of this type's fields */

empty(): T

/**

Get a field by name */

field(

key: string

): Field<any, any, any>

selection(

cursor: Cursor<T>,

pages: Pages<any>

): undefined | Selection<T>

toType(

schema: Schema<any>,

): Type<T>

}

/**

Optional settings to configure a Type */

export type TypeOptions<T>

{

/**

Accepts entries of these types as children */

contains: Array<string>

/**

An icon (React component) to represent this type in the dashboard */

icon: ComponentType

/**

Entries can be created as children of this entry */

isContainer: boolean

/**

Entries do not show up in the sidebar content tree */

isHidden: boolean

/**

A React component used to view a row of this type in the dashboard */

summaryRow: View<any>

/**

A React component used to view a thumbnail of this type in the dashboard */

summaryThumb: View<any>

/**

A React component used to view an entry of this type in the dashboard */

view: ComponentType

/**

Create indexes on fields of this type */

index<T>(

fields: Fields<T>

): Record<string, Array<Expr<any>>>

}

export type TypesOf<T>

= T extends HasType

? T["type"]

: string

export type UnionToIntersection<T>

= (T extends any

{}

: never

) extends {}

? R

: never

export function unreachable(

value: never

): never

export type User

{

sub: string

}

export function view<T, S extends SelectionInput, Params extends any>(

selection: ViewSelection<T, S>,

component: ComponentType<Params>

): View<T, Params>

export namespace View {

export function getSelection<T>(

schema: Schema<any>,

summaryView: "summaryRow" | "summaryThumb",

collection: Collection<T>

): Record<string, SelectionInput>

}

export type View<T, Props = any, S extends SelectionInput = SelectionInput>

= ComponentType<Props> &

{

selection: ViewSelectionGeneric

}

/**

Create a workspace */

export function workspace<T>(

label: Label,

options: WorkspaceOptions<T>

): WorkspaceConfig<T>

/**

Use a workspace to divide content. It is possible to create internal links between workspaces. */

export class Workspace<T = any> implements WorkspaceConfig<T>

{

constructor<T = any>(

config: WorkspaceConfig<T>

): Workspace<T>

config: WorkspaceConfig<T>

label: Label

options: WorkspaceOptions<T>

roots: Record<string, Root<string>>

schema: Schema<T>

get color(): string

get mediaDir(): undefined | string

get preview(): undefined | ComponentType<{entry: T, previewToken: string}>

get source(): string

get typeNamespace(): undefined | string

}

export type WorkspaceConfig<T = any>

{

label: Label

options: WorkspaceOptions<T>

}

export type WorkspaceOptions<T = any>

{

/**

The main theme color used in the dashboard */

color: string

/**

The directory where media files are placed in case a file backend is used */

mediaDir: string

/**

A react component used to preview an entry in the dashboard */

preview: ComponentType<

{

entry: T

previewToken: string

}

roots: Record<string, RootConfig>

/**

The schema of the workspace */

schema: SchemaConfig<T>

/**

Points to a Data.Source either by passing a directory or a file. - If the source is a directory, it will be scanned for files. - If the source is a file, it will be evaluated. */

source: string

/**

Generated types will be placed in this namespace */

typeNamespace: string

}

/**

A record of multiple named workspaces */

export type Workspaces

= Record<string, WorkspaceConfig>