@modern-js/module-tools 2.0.0-beta.2 → 2.0.0-beta.4

package/compiled/sass/types/legacy/render.d.ts

@@ -0,0 +1,139 @@
+import {LegacyException} from './exception';
+import {LegacyOptions} from './options';
+
+/**
+ * The object returned by [[render]] and [[renderSync]] after a successful
+ * compilation.
+ *
+ * @category Legacy
+ * @deprecated This is only used by the legacy [[render]] and [[renderSync]]
+ * APIs. Use [[compile]], [[compileString]], [[compileAsync]], and
+ * [[compileStringAsync]] instead.
+ */
+export interface LegacyResult {
+  /**
+   * The compiled CSS. This can be converted to a string by calling
+   * [Buffer.toString](https://nodejs.org/api/buffer.html#buffer_buf_tostring_encoding_start_end).
+   *
+   * @example
+   *
+   * ```js
+   * const result = sass.renderSync({file: "style.scss"});
+   *
+   * console.log(result.css.toString());
+   * ```
+   */
+  css: Buffer;
+
+  /**
+   * The source map that maps the compiled CSS to the source files from which it
+   * was generated. This can be converted to a string by calling
+   * [Buffer.toString](https://nodejs.org/api/buffer.html#buffer_buf_tostring_encoding_start_end).
+   *
+   * This is `undefined` unless either
+   *
+   * * [[LegacySharedOptions.sourceMap]] is a string; or
+   * * [[LegacySharedOptions.sourceMap]] is `true` and
+   *   [[LegacySharedOptions.outFile]] is set.
+   *
+   * The source map uses absolute [`file:`
+   * URLs](https://en.wikipedia.org/wiki/File_URI_scheme) to link to the Sass
+   * source files, except if the source file comes from
+   * [[LegacyStringOptions.data]] in which case it lists its URL as `"stdin"`.
+   *
+   * @example
+   *
+   * ```js
+   * const result = sass.renderSync({
+   *   file: "style.scss",
+   *   sourceMap: true,
+   *   outFile: "style.css"
+   * })
+   *
+   * console.log(result.map.toString());
+   * ```
+   */
+  map?: Buffer;
+
+  /** Additional information about the compilation. */
+  stats: {
+    /**
+     * The absolute path of [[LegacyFileOptions.file]] or
+     * [[LegacyStringOptions.file]], or `"data"` if [[LegacyStringOptions.file]]
+     * wasn't set.
+     */
+    entry: string;
+
+    /**
+     * The number of milliseconds between 1 January 1970 at 00:00:00 UTC and the
+     * time at which Sass compilation began.
+     */
+    start: number;
+
+    /**
+     * The number of milliseconds between 1 January 1970 at 00:00:00 UTC and the
+     * time at which Sass compilation ended.
+     */
+    end: number;
+
+    /**
+     * The number of milliseconds it took to compile the Sass file. This is
+     * always equal to `start` minus `end`.
+     */
+    duration: number;
+
+    /**
+     * An array of the absolute paths of all Sass files loaded during
+     * compilation. If a stylesheet was loaded from a [[LegacyImporter]] that
+     * returned the stylesheet’s contents, the raw string of the `@use` or
+     * `@import` that loaded that stylesheet included in this array.
+     */
+    includedFiles: string[];
+  };
+}
+
+/**
+ * This function synchronously compiles a Sass file to CSS. If it succeeds, it
+ * returns the result, and if it fails it throws an error.
+ *
+ * @example
+ *
+ * ```js
+ * const sass = require('sass'); // or require('node-sass');
+ *
+ * const result = sass.renderSync({file: "style.scss"});
+ * // ...
+ * ```
+ *
+ * @category Legacy
+ * @deprecated Use [[compile]] or [[compileString]] instead.
+ */
+export function renderSync(options: LegacyOptions<'sync'>): LegacyResult;
+
+/**
+
+ * This function asynchronously compiles a Sass file to CSS, and calls
+ * `callback` with a [[LegacyResult]] if compilation succeeds or
+ * [[LegacyException]] if it fails.
+ *
+ * **Heads up!** When using Dart Sass, **[[renderSync]] is almost twice as fast
+ * as [[render]]** by default, due to the overhead of making the entire
+ * evaluation process asynchronous.
+ *
+ * ```js
+ * const sass = require('sass'); // or require('node-sass');
+ *
+ * sass.render({
+ *   file: "style.scss"
+ * }, function(err, result) {
+ *   // ...
+ * });
+ * ```
+ *
+ * @category Legacy
+ * @deprecated Use [[compileAsync]] or [[compileStringAsync]] instead.
+ */
+export function render(
+  options: LegacyOptions<'async'>,
+  callback: (exception?: LegacyException, result?: LegacyResult) => void
+): void;

package/compiled/sass/types/logger/index.d.ts

@@ -0,0 +1,94 @@
+import {SourceSpan} from './source_span';
+
+export {SourceLocation} from './source_location';
+export {SourceSpan} from './source_span';
+
+/**
+ * An object that can be passed to [[LegacySharedOptions.logger]] to control how
+ * Sass emits warnings and debug messages.
+ *
+ * @example
+ *
+ * ```js
+ * const fs = require('fs');
+ * const sass = require('sass');
+ *
+ * let log = "";
+ * sass.renderSync({
+ *   file: 'input.scss',
+ *   logger: {
+ *     warn(message, options) {
+ *       if (options.span) {
+ *         log += `${span.url}:${span.start.line}:${span.start.column}: ` +
+ *             `${message}\n`;
+ *       } else {
+ *         log += `::: ${message}\n`;
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * fs.writeFileSync('log.txt', log);
+ * ```
+ *
+ * @category Logger
+ */
+export interface Logger {
+  /**
+   * This method is called when Sass emits a warning, whether due to a [`@warn`
+   * rule](https://sass-lang.com/documentation/at-rules/warn) or a warning
+   * generated by the Sass compiler.
+   *
+   * If this is `undefined`, Sass will print warnings to standard error.
+   *
+   * @param message - The warning message.
+   * @param options.deprecation - Whether this is a deprecation warning.
+   * @param options.span - The location in the Sass source code that generated this
+   * warning.
+   * @param options.stack - The Sass stack trace at the point the warning was issued.
+   */
+  warn?(
+    message: string,
+    options: {
+      deprecation: boolean;
+      span?: SourceSpan;
+      stack?: string;
+    }
+  ): void;
+
+  /**
+   * This method is called when Sass emits a debug message due to a [`@debug`
+   * rule](https://sass-lang.com/documentation/at-rules/debug).
+   *
+   * If this is `undefined`, Sass will print debug messages to standard error.
+   *
+   * @param message - The debug message.
+   * @param options.span - The location in the Sass source code that generated this
+   * debug message.
+   */
+  debug?(message: string, options: {span: SourceSpan}): void;
+}
+
+/**
+ * A namespace for built-in [[Logger]]s.
+ *
+ * @category Logger
+ * @compatibility dart: "1.43.0", node: false
+ */
+export namespace Logger {
+  /**
+   * A [[Logger]] that silently ignores all warnings and debug messages.
+   *
+   * @example
+   *
+   * ```js
+   * const sass = require('sass');
+   *
+   * const result = sass.renderSync({
+   *   file: 'input.scss',
+   *   logger: sass.Logger.silent,
+   * });
+   * ```
+   */
+  export const silent: Logger;
+}

package/compiled/sass/types/logger/source_location.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A specific location within a source file.
+ *
+ * This is always associated with a [[SourceSpan]] which indicates *which* file
+ * it refers to.
+ *
+ * @category Logger
+ */
+export interface SourceLocation {
+  /**
+   * The 0-based index of this location within its source file, in terms of
+   * UTF-16 code units.
+   */
+  offset: number;
+
+  /** The 0-based line number of this location. */
+  line: number;
+
+  /** The 0-based column number of this location. */
+  column: number;
+}

package/compiled/sass/types/logger/source_span.d.ts

@@ -0,0 +1,34 @@
+import {SourceLocation} from './source_location';
+
+/**
+ * A span of text within a source file.
+ *
+ * @category Logger
+ */
+export interface SourceSpan {
+  /** The beginning of this span, inclusive. */
+  start: SourceLocation;
+
+  /**
+   * The end of this span, exclusive.
+   *
+   * If [[start]] and [[end]] refer to the same location, the span has zero
+   * length and refers to the point immediately after [[start]] and before the
+   * next character.
+   */
+  end: SourceLocation;
+
+  /** The canonical URL of the file this span refers to. */
+  url?: URL;
+
+  /** The text covered by the span. */
+  text: string;
+
+  /**
+   * Text surrounding the span.
+   *
+   * If this is set, it must include only whole lines, and it must include at
+   * least all line(s) which are partially covered by this span.
+   */
+  context?: string;
+}