core

type Case int

type Charset []rune

type Collection struct {
	// Unique ID of this collection in the Notebook.
	ID CollectionID `json:"id"`
	// Kind of this note collection, such as a tag.
	Kind CollectionKind `json:"kind"`
	// Name of this collection.
	Name string `json:"name"`
	// Number of notes associated with this collection.
	NoteCount int `json:"note_count"`
}

type CollectionFormatter func(collection Collection) (string, error)

type CollectionID int64

type CollectionKind string

type CollectionRepository interface {

	// FindOrCreate returns the ID of the collection with given kind and name.
	// If the collection does not exist, creates a new one.
	FindOrCreateCollection(name string, kind CollectionKind) (CollectionID, error)

	// FindCollections returns the list of all collections in the repository
	// for the given kind, ordered with the given sorters.
	FindCollections(kind CollectionKind, sorters []CollectionSorter) ([]Collection, error)

	// AssociateNoteCollection creates a new association between a note and a
	// collection, if it does not already exist.
	AssociateNoteCollection(noteID NoteID, collectionID CollectionID) (NoteCollectionID, error)

	// RemoveNoteCollections deletes all collection associations with the given
	// note.
	RemoveNoteAssociations(noteId NoteID) error
}

type CollectionSortField int

type CollectionSorter struct {
	Field     CollectionSortField
	Ascending bool
}

type Config struct {
	Note    NoteConfig
	Groups  map[string]GroupConfig
	Format  FormatConfig
	Tool    ToolConfig
	LSP     LSPConfig
	Filters map[string]string
	Aliases map[string]string
	Extra   map[string]string
}

type ContextualNote struct {
	Note
	// List of context-sensitive excerpts from the note.
	Snippets []string
}

type Dir struct {
	// Name of the directory, which is the path relative to the notebook's root.
	Name string
	// Absolute path to the directory.
	Path string
	// Name of the config group this directory belongs to, if any.
	Group string
}

type ErrNoteExists struct {
	Name string
	Path string
}

type ErrNotebookNotFound string

type FileStorage interface {

	// WorkingDir returns the current working directory.
	WorkingDir() string

	// Abs makes the given file path absolute if needed, using the FileStorage
	// working directory.
	Abs(path string) (string, error)

	// Rel makes the given absolute file path relative to the current working
	// directory.
	Rel(path string) (string, error)

	// Canonical returns the canonical version of this path, resolving any
	// symbolic link.
	Canonical(path string) string

	// FileExists returns whether a file exists at the given file path.
	FileExists(path string) (bool, error)

	// DirExists returns whether a directory exists at the given file path.
	DirExists(path string) (bool, error)

	// IsDescendantOf returns whether the given path is dir or one of its descendants.
	IsDescendantOf(dir string, path string) (bool, error)

	// Read returns the bytes content of the file at the given file path.
	Read(path string) ([]byte, error)

	// Write creates or overwrite the content at the given file path, creating
	// any intermediate directories if needed.
	Write(path string, content []byte) error
}

type FormatConfig struct {
	Markdown MarkdownConfig
}

type GroupConfig struct {
	Paths []string
	Note  NoteConfig
	Extra map[string]string
}

type IDGenerator func() string

type IDGeneratorFactory func(opts IDOptions) func() string

type IDOptions struct {
	Length  int
	Charset Charset
	Case    Case
}

type InitOpts struct {
	WikiLinks     bool
	Hashtags      bool
	ColonTags     bool
	MultiwordTags bool
}

type LSPCompletionConfig struct {
	Note LSPCompletionTemplates
}

type LSPCompletionTemplates struct {
	Label      opt.String
	FilterText opt.String
	Detail     opt.String
}

type LSPConfig struct {
	Completion  LSPCompletionConfig
	Diagnostics LSPDiagnosticConfig
}

type LSPDiagnosticConfig struct {
	WikiTitle LSPDiagnosticSeverity
	DeadLink  LSPDiagnosticSeverity
}

type LSPDiagnosticSeverity int

type Link struct {
	// Label of the link.
	Title string `json:"title"`
	// Destination URI of the link.
	Href string `json:"href"`
	// Type of link, e.g. wiki link.
	Type LinkType `json:"type"`
	// Indicates whether the target is a remote (e.g. HTTP) resource.
	IsExternal bool `json:"isExternal"`
	// Relationships between the note and the linked target.
	Rels []LinkRelation `json:"rels"`
	// Excerpt of the paragraph containing the note.
	Snippet string `json:"snippet"`
	// Start byte offset of the snippet in the note content.
	SnippetStart int `json:"snippetStart"`
	// End byte offset of the snippet in the note content.
	SnippetEnd int `json:"snippetEnd"`
}

type LinkFilter struct {
	Hrefs       []string
	Negate      bool
	Recursive   bool
	MaxDistance int
}

type LinkFormatter func(context LinkFormatterContext) (string, error)

type LinkFormatterContext struct {
	// Filename of the note
	Filename string
	// File path to the note, relative to the notebook root.
	Path string
	// Absolute file path to the note.
	AbsPath string `handlebars:"abs-path"`
	// File path to the note, relative to the current directory.
	RelPath string `handlebars:"rel-path"`
	// Title of the note.
	Title string
	// Metadata extracted from the YAML frontmatter.
	Metadata map[string]interface{}
}

type LinkRelation string

type LinkType string

type MarkdownConfig struct {
	// Hashtags indicates whether #hashtags are supported.
	Hashtags bool
	// ColonTags indicates whether :colon:tags: are supported.
	ColonTags bool
	// MultiwordTags indicates whether #multi-word tags# are supported.
	MultiwordTags bool

	// Format used to generate links between notes.
	// Either "wiki", "markdown" or a custom template. Default is "markdown".
	LinkFormat string
	// Indicates whether a link's path will be percent-encoded.
	// Defaults to true for "markdown" format only, false otherwise.
	LinkEncodePath bool
	// Indicates whether a link's path file extension will be removed.
	LinkDropExtension bool
}

type MinimalNote struct {
	// Unique ID of this note in a notebook.
	ID NoteID
	// Path relative to the root of the notebook.
	Path string
	// Title of the note.
	Title string
	// JSON dictionary of raw metadata extracted from the frontmatter.
	Metadata map[string]interface{}
}

type NewNoteOpts struct {
	// Title of the new note.
	Title opt.String
	// Initial content of the note.
	Content string
	// Directory in which to create the note, relative to the root of the notebook.
	Directory opt.String
	// Group this note belongs to.
	Group opt.String
	// Path to a custom template used to render the note.
	Template opt.String
	// Extra variables passed to the templates.
	Extra map[string]string
	// Creation date provided to the templates.
	Date time.Time
	// Don't save the generated note on the file system.
	DryRun bool
}

type Note struct {
	// Unique ID of this note in a NoteRepository.
	ID NoteID
	// Path relative to the root of the notebook.
	Path string
	// Title of the note.
	Title string
	// First paragraph from the note body.
	Lead string
	// Content of the note, after any frontmatter and title heading.
	Body string
	// Whole raw content of the note.
	RawContent string
	// Number of words found in the content.
	WordCount int
	// List of outgoing links (internal or external) found in the content.
	Links []Link
	// List of tags found in the content.
	Tags []string
	// JSON dictionary of raw metadata extracted from the frontmatter.
	Metadata map[string]interface{}
	// Date of creation.
	Created time.Time
	// Date of last modification.
	Modified time.Time
	// Checksum of the note content.
	Checksum string
}

type NoteCollectionID int64

type NoteConfig struct {
	// Handlebars template used when generating a new filename.
	FilenameTemplate string
	// Extension appended to the filename.
	Extension string
	// Path to the handlebars template used when generating the note content.
	BodyTemplatePath opt.String
	// Language of the note content.
	Lang string
	// Default title to use when none is provided.
	DefaultTitle string
	// Settings used when generating a random ID.
	IDOptions IDOptions
	// Path globs to ignore when indexing notes.
	Ignore []string
}

type NoteContent struct {
	// Title is the heading of the note.
	Title opt.String
	// Lead is the opening paragraph or section of the note.
	Lead opt.String
	// Body is the content of the note, including the Lead but without the Title.
	Body opt.String
	// Tags is the list of tags found in the note content.
	Tags []string
	// Links is the list of outbound links found in the note.
	Links []Link
	// Additional metadata. For example, extracted from a YAML frontmatter.
	Metadata map[string]interface{}
}

type NoteContentParser interface {
	ParseNoteContent(content string) (*NoteContent, error)
}

type NoteFindOpts struct {
	// Filter used to match the notes with FTS predicates.
	Match opt.String
	// Search for exact occurrences of the Match string.
	ExactMatch bool
	// Filter by note hrefs.
	IncludeHrefs []string
	// Filter excluding notes at the given hrefs.
	ExcludeHrefs []string
	// Indicates whether href options can match any portion of a path.
	// This is used for wiki links.
	AllowPartialHrefs bool
	// Filter including notes with the given IDs.
	IncludeIDs []NoteID
	// Filter excluding notes with the given IDs.
	ExcludeIDs []NoteID
	// Filter by tags found in the notes.
	Tags []string
	// Filter the notes mentioning the given ones.
	Mention []string
	// Filter the notes mentioned by the given ones.
	MentionedBy []string
	// Filter to select notes being linked by another one.
	LinkedBy *LinkFilter
	// Filter to select notes linking to another one.
	LinkTo *LinkFilter
	// Filter to select notes which could might be related to the given notes hrefs.
	Related []string
	// Filter to select notes having no other notes linking to them.
	Orphan bool
	// Filter notes created after the given date.
	CreatedStart *time.Time
	// Filter notes created before the given date.
	CreatedEnd *time.Time
	// Filter notes modified after the given date.
	ModifiedStart *time.Time
	// Filter notes modified before the given date.
	ModifiedEnd *time.Time
	// Limits the number of results
	Limit int
	// Sorting criteria
	Sorters []NoteSorter
}

type NoteFormatter func(note ContextualNote) (string, error)

type NoteID int64

type NoteIndex interface {
	// Find retrieves the notes matching the given filtering and sorting criteria.
	Find(opts NoteFindOpts) ([]ContextualNote, error)
	// FindMinimal retrieves lightweight metadata for the notes matching the
	// given filtering and sorting criteria.
	FindMinimal(opts NoteFindOpts) ([]MinimalNote, error)

	// FindLinksBetweenNotes retrieves the links between the given notes.
	FindLinksBetweenNotes(ids []NoteID) ([]ResolvedLink, error)

	// FindCollections retrieves all the collections of the given kind.
	FindCollections(kind CollectionKind, sorters []CollectionSorter) ([]Collection, error)

	// Indexed returns the list of indexed note file metadata.
	IndexedPaths() (<-chan paths.Metadata, error)
	// Add indexes a new note.
	Add(note Note) (NoteID, error)
	// Update resets the metadata of an already indexed note.
	Update(note Note) error
	// Remove deletes a note from the index.
	Remove(path string) error

	// Commit performs a set of operations atomically.
	Commit(transaction func(idx NoteIndex) error) error

	// NeedsReindexing returns whether all notes should be reindexed.
	NeedsReindexing() (bool, error)
	// SetNeedsReindexing indicates whether all notes should be reindexed.
	SetNeedsReindexing(needsReindexing bool) error
}

type NoteIndexOpts struct {
	// When true, existing notes will be reindexed.
	Force   bool
	Verbose bool
}

type NoteIndexingStats struct {
	// Number of notes in the source.
	SourceCount int `json:"sourceCount"`
	// Number of newly indexed notes.
	AddedCount int `json:"addedCount"`
	// Number of notes modified since last indexing.
	ModifiedCount int `json:"modifiedCount"`
	// Number of notes removed since last indexing.
	RemovedCount int `json:"removedCount"`
	// Duration of the indexing process.
	Duration time.Duration `json:"duration"`
}

type NoteParser interface {
	ParseNoteAt(absPath string) (*Note, error)
}

type NoteSortField int

type NoteSorter struct {
	Field     NoteSortField
	Ascending bool
}

type Notebook struct {
	Path   string
	Config Config
	// contains filtered or unexported fields
}

type NotebookFactory func(path string, config Config) (*Notebook, error)

type NotebookPorts struct {
	NoteIndex             NoteIndex
	NoteContentParser     NoteContentParser
	TemplateLoaderFactory TemplateLoaderFactory
	IDGeneratorFactory    IDGeneratorFactory
	FS                    FileStorage
	Logger                util.Logger
	OSEnv                 func() map[string]string
}

type NotebookStore struct {
	// contains filtered or unexported fields
}

type NotebookStorePorts struct {
	NotebookFactory NotebookFactory
	TemplateLoader  TemplateLoader
	FS              FileStorage
}

type ResolvedLink struct {
	Link
	SourceID   NoteID `json:"sourceId"`
	SourcePath string `json:"sourcePath"`
	TargetID   NoteID `json:"targetId"`
	TargetPath string `json:"targetPath"`
}

type Style string

type Styler interface {
	// Style formats the given text according to the provided styling rules.
	Style(text string, rules ...Style) (string, error)
	// Style formats the given text according to the provided styling rules,
	// panicking if the rules are unknown.
	MustStyle(text string, rules ...Style) string
}

type Template interface {

	// Styler used to format the templates content.
	Styler() Styler

	// Render generates this template using the given variable context.
	Render(context interface{}) (string, error)
}

type TemplateFunc func(context interface{}) (string, error)

type TemplateLoader interface {
	// LoadTemplate creates a Template instance from a string template.
	LoadTemplate(template string) (Template, error)

	// LoadTemplate creates a Template instance from a template stored in the
	// file at the given path.
	// The path may be relative to template directories registered to the loader.
	LoadTemplateAt(path string) (Template, error)
}

type TemplateLoaderFactory func(language string) (TemplateLoader, error)

type ToolConfig struct {
	Editor     opt.String
	Pager      opt.String
	FzfPreview opt.String
	FzfLine    opt.String
}