@dotglitch/ngx-common 1.0.21 → 1.0.23

package/components/vscode/ts-type-resolver/types.d.ts

@@ -0,0 +1,179 @@
+import type * as monaco from 'monaco-editor';
+export interface SourceCache {
+    isFileAvailable?: (uri: string) => Promise<boolean>;
+    storeFile: (uri: string, content: string) => Promise<void>;
+    getFile: (uri: string) => Promise<string | undefined>;
+    clear: () => Promise<void>;
+}
+export type ProgressUpdate = {
+    type: 'CodeChanged';
+} | {
+    type: 'ResolveNewImports';
+} | {
+    type: 'LookedUpTypeFile';
+    path: string;
+    success: boolean;
+} | {
+    type: 'AttemptedLookUpFile';
+    path: string;
+    success: boolean;
+} | {
+    type: 'LookedUpPackage';
+    package: string;
+    definitelyTyped: boolean;
+    success: boolean;
+} | {
+    type: 'LoadedFromCache';
+    importPath: string;
+} | {
+    type: 'StoredToCache';
+    importPath: string;
+};
+export interface Options {
+    /**
+     * Share source cache between multiple editor instances by storing
+     * the cache in a static property.
+     *
+     * Defaults to false.
+     */
+    shareCache: boolean;
+    /**
+     * Only use packages specified in the `versions` property.
+     *
+     * Defaults to false.
+     */
+    onlySpecifiedPackages: boolean;
+    /**
+     * Load typings from prespecified versions when initializing. Versions
+     * need to be specified in the ``versions`` option.
+     *
+     * Defaults to false.
+     */
+    preloadPackages: boolean;
+    /**
+     * Updates compiler options to defaults suitable for auto-loaded
+     * declarations, specifically by setting ``moduleResolution`` to
+     * ``NodeJs`` and ``allowSyntheticDefaultImports`` to true.
+     * Other options are not changed. Set this property to true to
+     * disable this behaviour.
+     *
+     * Defaults to false.
+     */
+    dontAdaptEditorOptions: boolean;
+    /**
+     * After typings were resolved and injected into monaco, auto-typings
+     * updates the value of the current model to trigger a refresh in
+     * monaco's typing logic, so that it uses the injected typings.
+     */
+    dontRefreshModelValueAfterResolvement: boolean;
+    /**
+     * Prespecified package versions. If a package is loaded whose
+     * name is specified in this object, it will load with the exact
+     * version specified in the object.
+     *
+     * Example:
+     *
+     * ```json
+     * {
+     *   "@types/react": "17.0.0",
+     *   "csstype": "3.0.5"
+     * }
+     * ```
+     *
+     * Setting the option ``onlySpecifiedPackages`` to true makes this
+     * property act as a whitelist for packages.
+     *
+     * Setting the option ``preloadPackages`` makes the packages specified
+     * in this property load directly after initializing the auto-loader.
+     */
+    versions?: {
+        [packageName: string]: string;
+    };
+    /**
+     * If a new package was loaded, its name and version is added to the
+     * version object, and this method is called with the updated object.
+     * @param versions updated versions object.
+     */
+    onUpdateVersions?: (versions: {
+        [packageName: string]: string;
+    }) => void;
+    /**
+     * Supply a cache where declaration files and package.json files are
+     * cached to. Supply an instance of {@link LocalStorageCache} to cache
+     * files to localStorage.
+     */
+    sourceCache: SourceCache;
+    /**
+     * The root directory where your edited files are. Must end with
+     * a slash. The default is suitable unless you change the default
+     * URI of files loaded in the editor.
+     *
+     * Defaults to "inmemory://model/"
+     */
+    fileRootPath: string;
+    /**
+     * Debounces code reanalyzing after user has changed the editor contents
+     * by the specified amount. Set to zero to disable. Value provided in
+     * milliseconds.
+     *
+     * Defaults to 4000, i.e. 4 seconds.
+     */
+    debounceDuration: number;
+    /**
+     * Maximum recursion depth for recursing packages. Determines how many
+     * nested package declarations are loaded. For example, if ``packageRecursionDepth``
+     * has the value 2, the code in the monaco editor references packages ``A1``, ``A2``
+     * and ``A3``, package ``A1`` references package ``B1`` and ``B1`` references ``C1``,
+     * then packages ``A1``, ``A2``, ``A3`` and ``B1`` are loaded. Set to zero to
+     * disable.
+     *
+     * Defaults to 3.
+     */
+    packageRecursionDepth: number;
+    /**
+     * Maximum recursion depth for recursing files. Determines how many
+     * nested file declarations are loaded. The same as ``packageRecursionDepth``,
+     * but for individual files. Set to zero to disable.
+     *
+     * Defaults to 10.
+     */
+    fileRecursionDepth: number;
+    /**
+     * Called after progress updates like loaded declarations or events.
+     * @param update detailed event object containing update infos.
+     * @param textual a textual representation of the update for debugging.
+     */
+    onUpdate?: (update: ProgressUpdate, textual: string) => void;
+    /**
+     * Called if errors occur.
+     * @param error a textual representation of the error.
+     */
+    onError?: (error: string) => void;
+    /**
+     * instance of monaco editor
+     */
+    monaco: typeof monaco;
+}
+export interface ImportResourcePathPackage {
+    kind: 'package';
+    packageName: string;
+    importPath?: string;
+}
+export interface ImportResourcePathRelative {
+    kind: 'relative';
+    importPath: string;
+    sourcePath: string;
+}
+export interface ImportResourcePathRelativeInPackage {
+    kind: 'relative-in-package';
+    packageName: string;
+    importPath: string;
+    sourcePath: string;
+}
+export interface ImportResourceBruteForce {
+    kind: 'bruteforce';
+    packageName: string;
+    typingFiles: any[];
+}
+export type ImportResourcePath = ImportResourcePathPackage | ImportResourcePathRelative | ImportResourcePathRelativeInPackage | ImportResourceBruteForce;
+export declare const importResourcePathToString: (p: ImportResourcePath) => any;

package/components/vscode/ts-type-resolver/unpkg-source-resolver.d.ts

@@ -0,0 +1,5 @@
+export declare class UnpkgSourceResolver {
+    static resolvePackageJson(packageName: string, version: string | undefined, subPath: string | undefined): Promise<string | undefined>;
+    static resolveSourceFile(packageName: string, version: string | undefined, path: string): Promise<string | undefined>;
+    private static resolveFile;
+}

package/components/vscode/ts-type-resolver/update-emitter.d.ts

@@ -0,0 +1,2 @@
+import { ProgressUpdate, Options } from './types';
+export declare const invokeUpdate: (progress: ProgressUpdate, options: Options) => void;

package/components/vscode/vscode.component.d.ts

@@ -0,0 +1,57 @@
+import { AfterViewInit, EventEmitter, OnDestroy, SimpleChanges, ViewContainerRef } from '@angular/core';
+import * as MonacoEditor from 'monaco-editor';
+import * as i0 from "@angular/core";
+export declare class VscodeComponent implements AfterViewInit, OnDestroy {
+    private viewContainer;
+    isDirty: boolean;
+    editor: MonacoEditor.editor.IStandaloneCodeEditor;
+    filename: string;
+    private _code;
+    set code(value: string);
+    get code(): string;
+    codeChange: EventEmitter<string>;
+    private onCodeType;
+    private typeDebounce;
+    customLanguage: {
+        init: Function;
+    };
+    private _language;
+    set language(value: string);
+    get language(): string;
+    installationLocation: string;
+    tabSize: number;
+    readOnly: boolean;
+    theme: string;
+    fontFamily: string;
+    fontSize: number;
+    automaticLayout: boolean;
+    colorDecorators: boolean;
+    folding: boolean;
+    minimapEnabled: boolean;
+    minimap: MonacoEditor.editor.IEditorMinimapOptions;
+    scrollbar: MonacoEditor.editor.IEditorScrollbarOptions;
+    smoothScrolling: boolean;
+    mouseWheelScrollSensitivity: number;
+    scrollBeyondLastLine: boolean;
+    scrollBeyondLastColumn: number;
+    scrollbarAlwaysConsumeMouseWheel: number;
+    lineNumbers: MonacoEditor.editor.LineNumbersType;
+    get settings(): MonacoEditor.editor.IStandaloneEditorConstructionOptions;
+    verticalScrollExhausted: boolean;
+    private _sub;
+    constructor(viewContainer: ViewContainerRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): Promise<void>;
+    ngOnDestroy(): void;
+    private createEditor;
+    private configureLanguageSupport;
+    /**
+     * true if the monaco UMD files are injected into the webpage
+     */
+    private static isMonacoInstalled;
+    private installMonaco;
+    download(): void;
+    resize: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VscodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VscodeComponent, "app-vscode", never, { "code": "code"; "customLanguage": "customLanguage"; "language": "language"; "installationLocation": "installationLocation"; "tabSize": "tabSize"; "readOnly": "readOnly"; "theme": "theme"; "fontFamily": "fontFamily"; "fontSize": "fontSize"; "automaticLayout": "automaticLayout"; "colorDecorators": "colorDecorators"; "folding": "folding"; "minimapEnabled": "minimapEnabled"; "minimap": "minimap"; "scrollbar": "scrollbar"; "smoothScrolling": "smoothScrolling"; "mouseWheelScrollSensitivity": "mouseWheelScrollSensitivity"; "scrollBeyondLastLine": "scrollBeyondLastLine"; "scrollBeyondLastColumn": "scrollBeyondLastColumn"; "scrollbarAlwaysConsumeMouseWheel": "scrollbarAlwaysConsumeMouseWheel"; "lineNumbers": "lineNumbers"; }, { "codeChange": "codeChange"; }, never, never, true, never>;
+}