@realfavicongenerator/grunt-real-favicon
Version:
Generate a multiplatform favicon with RealFaviconGenerator and Grunt
154 lines (142 loc) • 6.77 kB
JavaScript
;
var grunt = require('grunt');
var imageAdapterNode = require('@realfavicongenerator/image-adapter-node');
var generateFavicon$1 = require('@realfavicongenerator/generate-favicon');
var injectMarkups = require('@realfavicongenerator/inject-markups');
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise, SuppressedError, Symbol */
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}
typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};
const toBuffer = (data) => __awaiter(void 0, void 0, void 0, function* () {
if (data instanceof Buffer) {
return data;
}
if (data instanceof Blob) {
return new Promise((resolve, reject) => {
const reader = new FileReader();
reader.onload = () => {
if (reader.result instanceof ArrayBuffer) {
resolve(Buffer.from(reader.result));
}
else {
reject(new Error('Failed to convert Blob to Buffer'));
}
};
reader.onerror = () => {
reject(new Error('Failed to read Blob'));
};
reader.readAsArrayBuffer(data);
});
}
return Buffer.from(data, 'utf8');
});
const generateFavicon = (task) => __awaiter(void 0, void 0, void 0, function* () {
var _a, e_1, _b, _c, _d, e_2, _e, _f;
const options = task.options({});
const imageAdapter = yield imageAdapterNode.getNodeImageAdapter();
const masterIcon = {
icon: yield imageAdapterNode.loadAndConvertToSvg(task.data.src),
};
grunt.file.mkdir(task.data.dest);
const settings = options.settings;
settings.path || (settings.path = '/');
// Generate files
const files = yield generateFavicon$1.generateFaviconFiles(masterIcon, settings, imageAdapter);
try {
for (var _g = true, _h = __asyncValues(Object.keys(files)), _j; _j = yield _h.next(), _a = _j.done, !_a; _g = true) {
_c = _j.value;
_g = false;
const fileName = _c;
const file = files[fileName];
const filePath = `${task.data.dest}/${fileName}`;
grunt.file.write(filePath, yield toBuffer(file));
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (!_g && !_a && (_b = _h.return)) yield _b.call(_h);
}
finally { if (e_1) throw e_1.error; }
}
// Generate HTML
const html = yield generateFavicon$1.generateFaviconHtml(settings);
const htmlFiles = grunt.file.expand({ nonull: true }, options.html);
try {
for (var _k = true, htmlFiles_1 = __asyncValues(htmlFiles), htmlFiles_1_1; htmlFiles_1_1 = yield htmlFiles_1.next(), _d = htmlFiles_1_1.done, !_d; _k = true) {
_f = htmlFiles_1_1.value;
_k = false;
const file = _f;
if (!grunt.file.exists(file)) {
grunt.log.verbose.writeln('The file "' + file + '" does not exist, creating the file so markup can be injected.');
grunt.file.write(file, html.markups.join('\n'));
}
else {
grunt.log.writeln('Injecting markup into file: ' + file);
const content = grunt.file.read(file);
const newContent = injectMarkups.injectMarkupInHtmlHead(content, html.markups, html.cssSelectors);
grunt.file.write(file, newContent);
}
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (!_k && !_d && (_e = htmlFiles_1.return)) yield _e.call(htmlFiles_1);
}
finally { if (e_2) throw e_2.error; }
}
});
/*
* grunt-real-favicon
* https://github.com/RealFaviconGenerator/core
*
* Copyright (c) 2024 Philippe Bernard
* Licensed under the MIT license.
*/
module.exports = function (grunt) {
grunt.registerMultiTask('realFavicon', 'Your favicon with RealFaviconGenerator and Grunt', function () {
const done = this.async();
generateFavicon(this).then(() => done());
});
};