grind-assets/lib/Commands/UnpublishCommand.js

Asset management for Grind

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.UnpublishCommand = void 0;

var _BaseCommand = require("./BaseCommand.js");

var _grindSupport = require("grind-support");

function _isnil(val) { return val === null || typeof val === 'undefined'; }

const path = require('path');

class UnpublishCommand extends _BaseCommand.BaseCommand {
  constructor(...args) {
    super(...args);
    this.name = 'assets:unpublish';
    this.description = 'Removes published assets';
  }

  async run() {
    await this.removePublishedAssets();
    await this.removeConfig();
  }

  async removePublishedAssets() {
    const dirs = [];
    const published = this.app.config.get('assets-published', {});

    if (!_isnil(published.__base_url)) {
      const length = published.__base_url.length;
      delete published.__base_url;

      for (const key of Object.keys(published)) {
        published[key] = published[key].substring(length);
      }
    }

    for (const key of Object.keys(published)) {
      const asset = published[key];
      this.comment('Removing asset', asset);
      dirs.push(path.dirname(asset));
      await this.removeAsset(asset);
    }

    await this.removeEmptyDirectories(dirs);
  }

  async removeEmptyDirectories(dirs) {
    dirs.sort((a, b) => a.length > b.length ? -1 : 1);

    for (const dir of dirs) {
      const path = this.app.paths.public(dir);
      const exists = await _grindSupport.FS.exists(path);

      if (!exists) {
        continue;
      }

      try {
        await _grindSupport.FS.rmdir(path);
      } catch (err) {
        Log.error('Failed to delete directory', dir, err);
      }
    }
  }

  removeConfig() {
    const path = this.app.paths.config('assets-published.json');
    return _grindSupport.FS.exists(path).then(exists => {
      if (!exists) {
        return;
      }

      return _grindSupport.FS.unlink(path);
    });
  }

}

exports.UnpublishCommand = UnpublishCommand;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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