[pull] master from DefinitelyTyped:master

types/gulp-sass/gulp-sass-tests.ts

@@ -1,17 +1,46 @@
 import gulp = require("gulp");
 import gulpSass = require("gulp-sass");
+import gulpSassLegacy = require("gulp-sass/legacy");
+import * as sass from "sass";
+import * as sassEmbedded from "sass-embedded";
 
-const sass = gulpSass({}); // compiler
+const gulpSassWithSass = gulpSass(sass);
+const gulpSassWithSassEmbedded = gulpSass(sassEmbedded);
+const gulpSassLegacyWithSass = gulpSassLegacy(sass);
 
 gulp.task("sass", function() {
     gulp.src("./scss/*.scss")
-        .pipe(sass())
+        .pipe(gulpSassWithSass({ style: "compressed" }))
         .pipe(gulp.dest("./css"));
 });
 
 gulp.task("sass", function() {
     gulp.src("./scss/*.scss")
-        .pipe(sass({ errLogToConsole: true }))
-        .pipe(sass.sync())
+        .pipe(gulpSassWithSass({ style: "compressed", importers: [new sass.NodePackageImporter(".")] }))
+        .pipe(gulp.dest("./css"));
+});
+
+gulp.task("sass", function() {
+    gulp.src("./scss/*.scss")
+        .pipe(gulpSassWithSassEmbedded({ style: "compressed", importers: [new sassEmbedded.NodePackageImporter(".")] }))
+        .pipe(gulp.dest("./css"));
+});
+
+gulp.task("sass", function() {
+    gulp.src("./scss/*.scss")
+        // @ts-expect-error -- The NodePackageImporter must come from the same implementation of Sass
+        .pipe(gulpSassWithSassEmbedded({ style: "compressed", importers: [new sass.NodePackageImporter(".")] }))
+        .pipe(gulp.dest("./css"));
+});
+
+gulp.task("sass", function() {
+    gulp.src("./scss/*.scss")
+        .pipe(gulpSassWithSass.sync())
+        .pipe(gulp.dest("./css"));
+});
+
+gulp.task("sass-legacy", function() {
+    gulp.src("./scss/*.scss")
+        .pipe(gulpSassLegacyWithSass({ outputStyle: "compressed" }))
         .pipe(gulp.dest("./css"));
 });

types/gulp-sass/index.d.ts

@@ -1,42 +1,34 @@
 /// <reference types="node"/>
 
-import { Options } from "node-sass";
+import { CompileResult, FileImporter, Importer, Options } from "@sass/types";
 
-interface SassResults {
-    css: string;
-    map: string;
-    stats: {
-        entry: string;
-        start: Date;
-        end: Date;
-        duration: number;
-        includedFiles: string[];
-    };
+interface GulpSassError extends Error {
+    messageFormatted: string;
+    messageOriginal: string;
+    relativePath: string;
 }
 
-interface SassOptions extends Options {
-    success?: ((results: SassResults) => any) | undefined;
-    error?: ((err: Error) => any) | undefined;
-    imagePaths?: string[] | undefined;
-}
+type GulpSassOptions<sync extends "sync" | "async", TNodePackageImporter extends {}> =
+    & Omit<Options<sync>, "importers">
+    & {
+        importers?: (Importer<sync> | FileImporter<sync> | TNodePackageImporter)[];
+    };
 
-interface GulpSassOptions extends SassOptions {
-    errLogToConsole?: boolean | undefined;
-    onSuccess?: ((css: string) => any) | undefined;
-    onError?: ((err: Error) => any) | undefined;
-    sync?: boolean | undefined;
+interface GulpSass<TNodePackageImporter extends {}> {
+    (opts?: GulpSassOptions<"async", TNodePackageImporter>): NodeJS.ReadWriteStream;
+    logError(error?: GulpSassError): void;
+    sync(options?: GulpSassOptions<"sync", TNodePackageImporter>): NodeJS.ReadWriteStream;
 }
 
-interface GulpSass {
-    (opts?: GulpSassOptions): NodeJS.ReadWriteStream;
-    logError(error?: string): void;
-    sync(options?: GulpSassOptions): NodeJS.ReadWriteStream;
+interface Compiler<TNodePackageImporter extends {}> {
+    compile(path: string, options: GulpSassOptions<"sync", TNodePackageImporter>): CompileResult;
+    compileAsync(path: string, options: GulpSassOptions<"async", TNodePackageImporter>): Promise<CompileResult>;
+    compileString(source: string, options: GulpSassOptions<"sync", TNodePackageImporter>): CompileResult;
+    compileStringAsync(source: string, options: GulpSassOptions<"async", TNodePackageImporter>): Promise<CompileResult>;
 }
 
-type Compiler = any;
-
 interface GulpSassFactory {
-    (compiler: Compiler): GulpSass;
+    <TNodePackageImporter extends {}>(compiler: Compiler<TNodePackageImporter>): GulpSass<TNodePackageImporter>;
 }
 
 declare var _tmp: GulpSassFactory;

types/gulp-sass/legacy.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node"/>
+
+import { LegacyException, LegacyResult, LegacySharedOptions } from "@sass/types";
+
+interface GulpSassError extends Error {
+    messageFormatted: string;
+    messageOriginal: string;
+    relativePath: string;
+}
+
+type LegacyGulpSassOptions<sync extends "sync" | "async", TNodePackageImporter extends {}> =
+    & Omit<LegacySharedOptions<sync>, "pkgImporter">
+    & {
+        pkgImporter?: TNodePackageImporter;
+    };
+
+interface LegacyGulpSass<TNodePackageImporter extends {}> {
+    (opts?: LegacyGulpSassOptions<"async", TNodePackageImporter>): NodeJS.ReadWriteStream;
+    logError(error?: GulpSassError): void;
+    sync(options?: LegacyGulpSassOptions<"sync", TNodePackageImporter>): NodeJS.ReadWriteStream;
+}
+
+interface GulpSassInjectedOptions {
+    data: string;
+    file?: string;
+    indentedSyntax?: boolean;
+}
+
+interface LegacyCompiler<TNodePackageImporter extends {}> {
+    render(
+        options: LegacyGulpSassOptions<"async", TNodePackageImporter> & GulpSassInjectedOptions,
+        callback: (exception?: LegacyException, result?: LegacyResult) => void,
+    ): void;
+    renderSync(options: LegacyGulpSassOptions<"sync", TNodePackageImporter> & GulpSassInjectedOptions): LegacyResult;
+}
+
+interface LegacyGulpSassFactory {
+    <TNodePackageImporter extends {}>(
+        compiler: LegacyCompiler<TNodePackageImporter>,
+    ): LegacyGulpSass<TNodePackageImporter>;
+}
+
+declare var _tmp: LegacyGulpSassFactory;
+export = _tmp;

types/gulp-sass/package.json

@@ -1,15 +1,17 @@
 {
     "private": true,
     "name": "@types/gulp-sass",
-    "version": "5.0.9999",
+    "version": "6.0.9999",
     "projects": [
         "https://github.com/dlmanning/gulp-sass"
     ],
     "dependencies": {
-        "@types/node": "*",
-        "@types/node-sass": "*"
+        "@sass/types": "^1.93",
+        "@types/node": "*"
     },
     "devDependencies": {
+        "sass": "^1.93",
+        "sass-embedded": "^1.93",
         "@types/gulp": "*",
         "@types/gulp-sass": "workspace:."
     },

types/gulp-sass/tsconfig.json

@@ -14,6 +14,7 @@
     },
     "files": [
         "index.d.ts",
+        "legacy.d.ts",
         "gulp-sass-tests.ts"
     ]
 }