modern-monaco 0.0.0-beta.0

package/types/index.d.ts

@@ -0,0 +1,47 @@
+import type monacoNS from "./monaco.d.ts";
+import type { LSPConfig } from "./lsp.d.ts";
+import type { TextmateGrammarName, TextmateThemeName } from "./textmate.d.ts";
+import type { Workspace } from "./workspace.d.ts";
+
+type Awaitable<T> = T | Promise<T>;
+type MaybeGetter<T> = Awaitable<MaybeModule<T>> | (() => Awaitable<MaybeModule<T>>);
+type MaybeModule<T> = T | { default: T };
+type MaybeArray<T> = T | T[];
+type LanguageInput = MaybeGetter<MaybeArray<NamedObject>>;
+type ThemeInput = MaybeGetter<NamedObject>;
+
+interface NamedObject {
+  name: string;
+}
+
+export interface ShikiInitOptions {
+  /**
+   * Theme names, or theme registration objects to be loaded upfront.
+   */
+  theme?: TextmateThemeName | URL | ThemeInput;
+  /**
+   * Language names, or language registration objects to be loaded upfront.
+   */
+  langs?: (TextmateGrammarName | URL | LanguageInput)[];
+  /**
+   * The CDN base URL to download themes and languages from. Default: "https://esm.sh".
+   */
+  downloadCDN?: string;
+}
+
+export interface InitOptions extends ShikiInitOptions {
+  /**
+   * Virtual file system to be used by the editor.
+   */
+  workspace?: Workspace;
+  /**
+   * Language server protocol configuration.
+   */
+  lsp?: LSPConfig;
+}
+
+export function init(options?: InitOptions): Promise<typeof monacoNS>;
+export function lazy(options?: InitOptions): void;
+export function hydrate(options?: InitOptions): void;
+
+export { Workspace };

package/types/jsonSchema.d.ts

@@ -0,0 +1,90 @@
+export type JSONSchemaRef = JSONSchema | boolean;
+export interface JSONSchema {
+    id?: string;
+    $id?: string;
+    $schema?: string;
+    type?: string | string[];
+    title?: string;
+    default?: any;
+    definitions?: {
+        [name: string]: JSONSchema;
+    };
+    description?: string;
+    properties?: JSONSchemaMap;
+    patternProperties?: JSONSchemaMap;
+    additionalProperties?: JSONSchemaRef;
+    minProperties?: number;
+    maxProperties?: number;
+    dependencies?: JSONSchemaMap | {
+        [prop: string]: string[];
+    };
+    items?: JSONSchemaRef | JSONSchemaRef[];
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    additionalItems?: JSONSchemaRef;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: boolean | number;
+    exclusiveMaximum?: boolean | number;
+    multipleOf?: number;
+    required?: string[];
+    $ref?: string;
+    anyOf?: JSONSchemaRef[];
+    allOf?: JSONSchemaRef[];
+    oneOf?: JSONSchemaRef[];
+    not?: JSONSchemaRef;
+    enum?: any[];
+    format?: string;
+    const?: any;
+    contains?: JSONSchemaRef;
+    propertyNames?: JSONSchemaRef;
+    examples?: any[];
+    $comment?: string;
+    if?: JSONSchemaRef;
+    then?: JSONSchemaRef;
+    else?: JSONSchemaRef;
+    unevaluatedProperties?: boolean | JSONSchemaRef;
+    unevaluatedItems?: boolean | JSONSchemaRef;
+    minContains?: number;
+    maxContains?: number;
+    deprecated?: boolean;
+    dependentRequired?: {
+        [prop: string]: string[];
+    };
+    dependentSchemas?: JSONSchemaMap;
+    $defs?: {
+        [name: string]: JSONSchema;
+    };
+    $anchor?: string;
+    $recursiveRef?: string;
+    $recursiveAnchor?: string;
+    $vocabulary?: any;
+    prefixItems?: JSONSchemaRef[];
+    $dynamicRef?: string;
+    $dynamicAnchor?: string;
+    defaultSnippets?: {
+        label?: string;
+        description?: string;
+        markdownDescription?: string;
+        body?: any;
+        bodyText?: string;
+    }[];
+    errorMessage?: string;
+    patternErrorMessage?: string;
+    deprecationMessage?: string;
+    enumDescriptions?: string[];
+    markdownEnumDescriptions?: string[];
+    markdownDescription?: string;
+    doNotSuggest?: boolean;
+    suggestSortText?: string;
+    allowComments?: boolean;
+    allowTrailingCommas?: boolean;
+    completionDetail?: string;
+}
+export interface JSONSchemaMap {
+    [name: string]: JSONSchemaRef;
+}

package/types/lsp.d.ts

@@ -0,0 +1,106 @@
+import type ts from "typescript";
+import type monacoNS from "./monaco.d.ts";
+import type { ImportMap } from "./import-map.d.ts";
+import type { JSONSchema } from "./jsonSchema.d.ts";
+import type { Workspace } from "./workspace.d.ts";
+
+export interface FormatOptions {
+  /** Size of a tab in spaces. Default: 4. */
+  tabSize?: number;
+  /** Prefer spaces over tabs. Default: true.*/
+  insertSpaces?: boolean;
+  /** Trim trailing whitespace on a line. Default: true. */
+  trimTrailingWhitespace?: boolean;
+  /** Insert a newline character at the end of the file if one does not exist. Default: false. */
+  insertFinalNewline?: boolean;
+  /** Trim all newlines after the final newline at the end of the file. Default: false. */
+  trimFinalNewlines?: boolean;
+  /** Semicolon preference for JavaScript and TypeScript. Default: "insert". */
+  semicolon?: "ignore" | "insert" | "remove";
+}
+
+export interface JSONSchemaSource {
+  /**
+   * The URI of the schema, which is also the identifier of the schema.
+   */
+  uri: string;
+  /**
+   * A list of glob patterns that describe for which file URIs the JSON schema will be used.
+   * '*' and '**' wildcards are supported. Exclusion patterns start with '!'.
+   * For example '*.schema.json', 'package.json', '!foo*.schema.json', 'foo/**\/BADRESP.json'.
+   * A match succeeds when there is at least one pattern matching and last matching pattern does not start with '!'.
+   */
+  fileMatch?: string[];
+  /**
+   * The schema for the given URI.
+   * If no schema is provided, the schema will be fetched with the schema request service (if available).
+   */
+  schema?: JSONSchema;
+  /**
+   * A parent folder for folder specifc associations. An association that has a folder URI set is only used
+   * if the document that is validated has the folderUri as parent
+   */
+  folderUri?: string;
+}
+
+export interface IReference {
+  name: string;
+  url: string;
+}
+export interface IData {
+  name: string;
+  description?: string;
+  references?: IReference[];
+}
+export interface IAttributeData extends IData {
+  valueSet?: string;
+  values?: IData[];
+}
+export interface ITagData extends IData {
+  attributes: IAttributeData[];
+  void?: boolean;
+}
+
+export interface LSP {
+  setup: (
+    monaco: typeof monacoNS,
+    languageId: string,
+    langaugeSettings?: Record<string, unknown>,
+    formattingOptions?: Record<string, unknown>,
+    workspace?: Workspace,
+  ) => Promise<void>;
+  getWorkerUrl: () => URL;
+}
+
+export interface LSPProvider {
+  aliases?: string[];
+  syntaxes?: any[];
+  import: () => Promise<LSP>;
+}
+
+export interface LSPConfig extends LSPLanguageConfig {
+  providers?: Record<string, LSPProvider>;
+  formatting?: FormatOptions;
+}
+
+declare global {
+  interface LSPLanguageConfig {
+    html?: {
+      attributeDefaultValue?: "empty" | "singlequotes" | "doublequotes";
+      customTags?: ITagData[];
+      hideAutoCompleteProposals?: boolean;
+    };
+    css?: {};
+    json?: {
+      schemas?: JSONSchemaSource[];
+    };
+    typescript?: {
+      /** The compiler options. */
+      compilerOptions?: ts.CompilerOptions;
+      /** The global import maps. */
+      importMap?: ImportMap;
+      /** The version of the typescript imported from esm.sh CDN. Default: ">= 5.5.0" */
+      tsVersion?: string;
+    };
+  }
+}