@openzim/libzim 2.4.4 → 3.1.0

package/src/writerItem.h

@@ -0,0 +1,462 @@
+#pragma once
+
+#include <napi.h>
+#include <zim/writer/contentProvider.h>
+#include <zim/writer/item.h>
+
+#include <exception>
+#include <functional>
+#include <future>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <thread>
+
+#include "blob.h"
+#include "common.h"
+#include "contentProvider.h"
+
+zim::writer::Hints Object2Hints(const Napi::Object &obj) {
+  zim::writer::Hints hints{};
+  if (obj.Has("COMPRESS")) {
+    hints[zim::writer::COMPRESS] = obj["COMPRESS"].ToNumber().Int64Value();
+  }
+
+  if (obj.Has("FRONT_ARTICLE")) {
+    hints[zim::writer::FRONT_ARTICLE] =
+        obj["FRONT_ARTICLE"].ToNumber().Int64Value();
+  }
+
+  return hints;
+}
+
+/**
+ * Wraps a JS World Object to IndexData and implements IndexData
+ */
+class IndexDataWrapper : public zim::writer::IndexData {
+ public:
+  explicit IndexDataWrapper(const Napi::Object &indexData)
+      : hasIndexData_{true},
+        title_{},
+        content_{},
+        keywords_{},
+        wordcount_{},
+        position_{std::nullopt} {
+    if (indexData.Has("hasIndexData"))
+      hasIndexData_ = indexData.Get("hasIndexData").ToBoolean();
+
+    if (!hasIndexData_) return;
+
+    if (indexData.Has("title")) title_ = indexData.Get("title").ToString();
+    if (indexData.Has("content"))
+      content_ = indexData.Get("content").ToString();
+    if (indexData.Has("keywords"))
+      keywords_ = indexData.Get("keywords").ToString();
+    if (indexData.Has("wordcount"))
+      wordcount_ = indexData.Get("wordcount").ToNumber();
+
+    if (indexData.Has("position") && indexData.Get("position").IsArray()) {
+      auto pos = indexData.Get("position").As<Napi::Array>();
+      if (pos.Length() < 3) {
+        throw Napi::Error::New(indexData.Env(),
+                               "position must have a length of 3");
+      }
+      position_ =
+          std::make_tuple(pos.Get((uint32_t)0).ToBoolean().Value(),
+                          pos.Get((uint32_t)1).ToNumber().DoubleValue(),
+                          pos.Get((uint32_t)2).ToNumber().DoubleValue());
+    }
+
+    hasIndexData_ = !(title_.empty() && content_.empty() && keywords_.empty() &&
+                      wordcount_ > 0 && !position_.has_value());
+  }
+
+  bool hasIndexData() const override { return hasIndexData_; }
+
+  std::string getTitle() const override { return title_; }
+  std::string getContent() const override { return content_; }
+  std::string getKeywords() const override { return keywords_; }
+  uint32_t getWordCount() const override { return wordcount_; }
+  GeoPosition getGeoPosition() const override { return *position_; }
+
+ private:
+  bool hasIndexData_;
+  std::string title_;
+  std::string content_;
+  std::string keywords_;
+  uint32_t wordcount_;
+  std::optional<GeoPosition> position_;
+};
+
+/**
+ * Wraps a JS World Item to a zim::writer::Item
+ *
+ * NOTE: should be initialized on the main thread
+ */
+class ItemWrapper : public zim::writer::Item {
+ public:
+  ItemWrapper(Napi::Env env, Napi::Object item)
+      : MAIN_THREAD_ID{}, item_{}, hasIndexDataImpl_{false} {
+    MAIN_THREAD_ID = std::this_thread::get_id();
+    item_ = Napi::Persistent(item);
+
+    path_ = item.Get("path").ToString();
+    title_ = item.Get("title").ToString();
+    mimeType_ = item.Get("mimeType").ToString();
+
+    const auto hasHints = item.Has("hints");
+    hints_ = hasHints ? Object2Hints(item.Get("hints").ToObject())
+                      : zim::writer::Item::getHints();
+
+    hasIndexDataImpl_ = item.Has("hasIndexData");
+
+    if (hasIndexDataImpl_) {
+      auto indexDataFuncValue = item.Get("getIndexData");
+      if (!indexDataFuncValue.IsFunction()) {
+        throw std::runtime_error("getIndexData must be a function");
+      }
+
+      auto indexDataFunc = indexDataFuncValue.As<Napi::Function>();
+      indexDataFunc_ = Napi::Persistent(indexDataFunc);
+      indexDataTSNF_ = Napi::ThreadSafeFunction::New(
+          env, indexDataFunc, "ItemWrapper.indexData", 0, 1);
+    }
+
+    auto providerFuncValue = item.Get("getContentProvider");
+    if (!providerFuncValue.IsFunction()) {
+      throw std::runtime_error("getContentProvider must be a function");
+    }
+    auto providerFunc = providerFuncValue.As<Napi::Function>();
+    contentProviderFunc_ = Napi::Persistent(providerFunc);
+    contentProviderTSNF_ = Napi::ThreadSafeFunction::New(
+        env, providerFunc, "ItemWrapper.contentProvider", 5, 1);
+  }
+
+  ~ItemWrapper() {
+    if (hasIndexDataImpl_) {
+      indexDataTSNF_.Release();
+    }
+    contentProviderTSNF_.Release();
+  }
+
+  std::string getPath() const override { return path_; }
+
+  std::string getTitle() const override { return title_; }
+
+  std::string getMimeType() const override { return mimeType_; }
+
+  zim::writer::Hints getHints() const override { return hints_; }
+
+  std::shared_ptr<zim::writer::IndexData> getIndexData() const override {
+    if (!hasIndexDataImpl_) {
+      // use default implementation
+      return zim::writer::Item::getIndexData();
+    }
+
+    if (MAIN_THREAD_ID == std::this_thread::get_id()) {
+      auto data = indexDataFunc_.Call(item_.Value(), {});
+      return data.IsObject()
+                 ? std::make_shared<IndexDataWrapper>(data.ToObject())
+                 : nullptr;
+    }
+
+    // called from a thread
+    using IndexDataWrapperPtr = std::shared_ptr<IndexDataWrapper>;
+    std::promise<IndexDataWrapperPtr> promise;
+    auto future = promise.get_future();
+
+    auto callback = [&promise, this](Napi::Env env, Napi::Function idxFunc) {
+      auto data = idxFunc.Call(item_.Value(), {});
+      promise.set_value(
+          data.IsObject() ? std::make_shared<IndexDataWrapper>(data.ToObject())
+                          : nullptr);
+    };
+
+    auto status = indexDataTSNF_.BlockingCall(callback);
+    if (status != napi_ok) {
+      throw std::runtime_error("Error calling indexData ThreadSafeFunction");
+    }
+
+    return future.get();
+  }
+
+  /**
+   * ContentProvider is dynamic and must be created on the main javascript
+   * thread.
+   */
+  std::unique_ptr<zim::writer::ContentProvider> getContentProvider()
+      const override {
+    if (MAIN_THREAD_ID == std::this_thread::get_id()) {
+      auto env = contentProviderFunc_.Env();
+      auto provider = contentProviderFunc_.Call(item_.Value(), {});
+      if (provider.IsObject()) {
+        return std::make_unique<ContentProviderWrapper>(env,
+                                                        provider.ToObject());
+      } else if (provider.IsNull() || provider.IsUndefined()) {
+        return nullptr;
+      }
+
+      throw std::runtime_error(
+          "getContentProvider must return an object or null");
+    }
+
+    using ContentProviderWrapperPtr = std::unique_ptr<ContentProviderWrapper>;
+    std::promise<ContentProviderWrapperPtr> promise;
+    auto future = promise.get_future();
+
+    auto callback = [&promise, this](Napi::Env env,
+                                     Napi::Function providerFunc) {
+      auto provider = providerFunc.Call(item_.Value(), {});
+      if (provider.IsObject()) {
+        auto ptr =
+            std::make_unique<ContentProviderWrapper>(env, provider.ToObject());
+        promise.set_value(std::move(ptr));
+      } else if (provider.IsNull() || provider.IsUndefined()) {
+        promise.set_value(nullptr);
+      } else {
+        throw std::runtime_error(
+            "getContentProvider must return an object or null");
+      }
+    };
+
+    auto status = contentProviderTSNF_.BlockingCall(callback);
+    if (status != napi_ok) {
+      throw std::runtime_error(
+          "Error calling contentProvider ThreadSafeFunction");
+    }
+
+    return future.get();
+  }
+
+ private:
+  std::thread::id MAIN_THREAD_ID;
+  // js world reference, could be an ObjectWrap provider or custom js object
+  Napi::ObjectReference item_;
+
+  std::string path_;
+  std::string title_;
+  std::string mimeType_;
+  zim::writer::Hints hints_;
+  bool hasIndexDataImpl_;
+
+  Napi::FunctionReference indexDataFunc_;
+  Napi::ThreadSafeFunction indexDataTSNF_;
+  Napi::FunctionReference contentProviderFunc_;
+  Napi::ThreadSafeFunction contentProviderTSNF_;
+};
+
+class StringItem : public Napi::ObjectWrap<StringItem> {
+ public:
+  explicit StringItem(const Napi::CallbackInfo &info)
+      : Napi::ObjectWrap<StringItem>(info), item_{nullptr} {
+    auto env = info.Env();
+    if (info.Length() < 5) {
+      throw Napi::Error::New(env,
+                             "StringItem requires arguments (path, mimetype, "
+                             "title, hints, content)");
+    }
+
+    try {
+      auto path = info[0].ToString().Utf8Value();
+      auto mimetype = info[1].ToString().Utf8Value();
+      auto title = info[2].ToString().Utf8Value();
+      auto hints = Object2Hints(info[3].ToObject());
+
+      const auto &&cval = info[4];
+      std::string content;
+
+      if (cval.IsArrayBuffer()) {  // handle ArrayBuffer
+        auto buf = cval.As<Napi::ArrayBuffer>();
+        auto size = buf.ByteLength();
+        content = std::string(reinterpret_cast<const char *>(buf.Data()), size);
+      } else if (cval.IsBuffer()) {  // handle Buffer
+        auto buf = cval.As<Napi::Buffer<char>>();
+        auto size = buf.Length();
+        content = std::string(reinterpret_cast<const char *>(buf.Data()), size);
+      } else {
+        content = cval.ToString().Utf8Value();
+      }
+
+      item_ = zim::writer::StringItem::create(path, mimetype, title, hints,
+                                              content);
+    } catch (const std::exception &e) {
+      throw Napi::Error::New(env, e.what());
+    }
+  }
+
+  std::shared_ptr<zim::writer::StringItem> getItem() { return item_; }
+
+  Napi::Value getPath(const Napi::CallbackInfo &info) {
+    try {
+      return Napi::Value::From(info.Env(), item_->getPath());
+    } catch (const std::exception &err) {
+      throw Napi::Error::New(info.Env(), err.what());
+    }
+  }
+
+  Napi::Value getTitle(const Napi::CallbackInfo &info) {
+    try {
+      return Napi::Value::From(info.Env(), item_->getTitle());
+    } catch (const std::exception &err) {
+      throw Napi::Error::New(info.Env(), err.what());
+    }
+  }
+
+  Napi::Value getMimeType(const Napi::CallbackInfo &info) {
+    try {
+      return Napi::Value::From(info.Env(), item_->getMimeType());
+    } catch (const std::exception &err) {
+      throw Napi::Error::New(info.Env(), err.what());
+    }
+  }
+
+  Napi::Value getHints(const Napi::CallbackInfo &info) {
+    try {
+      auto env = info.Env();
+      auto hints = item_->getHints();
+      auto obj = Napi::Object::New(env);
+      if (hints.find(zim::writer::COMPRESS) != hints.end()) {
+        obj.Set("COMPRESS",
+                Napi::Value::From(env, hints[zim::writer::COMPRESS]));
+      }
+      if (hints.find(zim::writer::FRONT_ARTICLE) != hints.end()) {
+        obj.Set("FRONT_ARTICLE",
+                Napi::Value::From(env, hints[zim::writer::FRONT_ARTICLE]));
+      }
+      return obj;
+    } catch (const std::exception &err) {
+      throw Napi::Error::New(info.Env(), err.what());
+    }
+  }
+
+  Napi::Value getContentProvider(const Napi::CallbackInfo &info) {
+    try {
+      return StringProvider::New(info.Env(), item_->getContentProvider());
+    } catch (const std::exception &err) {
+      throw Napi::Error::New(info.Env(), err.what());
+    }
+  }
+
+  // TODO(kelvinhammond): implement getIndexData for StringItem and FileItem
+
+  static void Init(Napi::Env env, Napi::Object exports,
+                   ModuleConstructors &constructors) {
+    Napi::HandleScope scope(env);
+    Napi::Function func =
+        DefineClass(env, "StringItem",
+                    {
+                        InstanceAccessor<&StringItem::getPath>("path"),
+                        InstanceAccessor<&StringItem::getTitle>("title"),
+                        InstanceAccessor<&StringItem::getMimeType>("mimeType"),
+                        InstanceMethod<&StringItem::getContentProvider>(
+                            "getContentProvider"),
+                        InstanceAccessor<&StringItem::getHints>("hints"),
+                    });
+
+    exports.Set("StringItem", func);
+    constructors.stringItem = Napi::Persistent(func);
+  }
+
+ private:
+  std::shared_ptr<zim::writer::StringItem> item_;
+};
+
+class FileItem : public Napi::ObjectWrap<FileItem> {
+ public:
+  explicit FileItem(const Napi::CallbackInfo &info)
+      : Napi::ObjectWrap<FileItem>(info), item_{nullptr} {
+    auto env = info.Env();
+    if (info.Length() < 5) {
+      throw Napi::Error::New(env,
+                             "FileItem requires arguments (path, mimetype, "
+                             "title, hints, content)");
+    }
+
+    try {
+      auto path = info[0].ToString();
+      auto mimetype = info[1].ToString();
+      auto title = info[2].ToString();
+      auto hints = Object2Hints(info[3].ToObject());
+      auto filepath = info[4].ToString();
+      item_ = std::make_shared<zim::writer::FileItem>(path, mimetype, title,
+                                                      hints, filepath);
+    } catch (const std::exception &e) {
+      throw Napi::Error::New(env, e.what());
+    }
+  }
+
+  std::shared_ptr<zim::writer::FileItem> getItem() { return item_; }
+
+  Napi::Value getPath(const Napi::CallbackInfo &info) {
+    try {
+      return Napi::Value::From(info.Env(), item_->getPath());
+    } catch (const std::exception &err) {
+      throw Napi::Error::New(info.Env(), err.what());
+    }
+  }
+
+  Napi::Value getTitle(const Napi::CallbackInfo &info) {
+    try {
+      return Napi::Value::From(info.Env(), item_->getTitle());
+    } catch (const std::exception &err) {
+      throw Napi::Error::New(info.Env(), err.what());
+    }
+  }
+
+  Napi::Value getMimeType(const Napi::CallbackInfo &info) {
+    try {
+      return Napi::Value::From(info.Env(), item_->getMimeType());
+    } catch (const std::exception &err) {
+      throw Napi::Error::New(info.Env(), err.what());
+    }
+  }
+
+  Napi::Value getHints(const Napi::CallbackInfo &info) {
+    try {
+      auto env = info.Env();
+      auto hints = item_->getHints();
+      auto obj = Napi::Object::New(env);
+      if (hints.find(zim::writer::COMPRESS) != hints.end()) {
+        obj.Set("COMPRESS",
+                Napi::Value::From(env, hints[zim::writer::COMPRESS]));
+      }
+      if (hints.find(zim::writer::FRONT_ARTICLE) != hints.end()) {
+        obj.Set("FRONT_ARTICLE",
+                Napi::Value::From(env, hints[zim::writer::FRONT_ARTICLE]));
+      }
+      return obj;
+    } catch (const std::exception &err) {
+      throw Napi::Error::New(info.Env(), err.what());
+    }
+  }
+
+  Napi::Value getContentProvider(const Napi::CallbackInfo &info) {
+    try {
+      return FileProvider::New(info.Env(), item_->getContentProvider());
+    } catch (const std::exception &err) {
+      throw Napi::Error::New(info.Env(), err.what());
+    }
+  }
+
+  static void Init(Napi::Env env, Napi::Object exports,
+                   ModuleConstructors &constructors) {
+    Napi::HandleScope scope(env);
+    Napi::Function func = DefineClass(
+        env, "FileItem",
+        {
+            InstanceAccessor<&FileItem::getPath>("path"),
+            InstanceAccessor<&FileItem::getTitle>("title"),
+            InstanceAccessor<&FileItem::getMimeType>("mimeType"),
+            InstanceMethod<&FileItem::getContentProvider>("getContentProvider"),
+            InstanceAccessor<&FileItem::getHints>("hints"),
+        });
+
+    exports.Set("FileItem", func);
+    constructors.fileItem = Napi::Persistent(func);
+  }
+
+ private:
+  std::shared_ptr<zim::writer::FileItem> item_;
+};
+

package/tsconfig.json

@@ -2,16 +2,14 @@
   "compilerOptions": {
     "module": "commonjs",
     "lib": [
-      "es2015"
+      "es6"
     ],
+    "allowJs": true,
     "declaration": true,
     "noImplicitAny": true,
     "outDir": "dist",
     "removeComments": false,
-    "target": "es5",
+    "target": "es6",
     "esModuleInterop": true
-  },
-  "files": [
-    "src/index.ts"
-  ]
+  }
 }

package/dist/ZimCreator.d.ts

@@ -1,34 +0,0 @@
-export interface ZimCreatorOpts {
-    fileName: string;
-    welcome?: string;
-    compression?: string;
-    fullTextIndexLanguage?: string;
-    minChunkSize?: number;
-}
-export interface ZimMetadata {
-    Counter?: string;
-    Creator?: string;
-    Date?: string;
-    Description?: string;
-    Flavour?: string;
-    Language?: string;
-    Name?: string;
-    Publisher?: string;
-    Tags?: string;
-    Title?: string;
-}
-declare class ZimCreator {
-    tmpDir: string;
-    _creator: any;
-    fileName: string;
-    compression: string;
-    articleCounter: {
-        [mimeType: string]: number;
-    };
-    constructor(opts: ZimCreatorOpts, metadata?: ZimMetadata);
-    get isAlive(): boolean;
-    addArticle(article: any): Promise<any>;
-    setMetadata(metadata: ZimMetadata): Promise<void>;
-    finalise(): Promise<void>;
-}
-export { ZimCreator };

package/dist/ZimCreator.js

@@ -1,177 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZimCreator = void 0;
-var fs_1 = require("fs");
-var mime = __importStar(require("mime"));
-var rimraf = __importStar(require("rimraf"));
-var zim_1 = require("./zim");
-var ZimCreator = /** @class */ (function () {
-    function ZimCreator(opts, metadata) {
-        if (metadata === void 0) { metadata = {}; }
-        this.articleCounter = {};
-        this.fileName = opts.fileName;
-        this.compression = opts.compression || 'lzma';
-        this.articleCounter = {};
-        this.tmpDir = this.fileName.split('.').slice(0, -1).join('.') + '.tmp';
-        var metadataDefaults = {
-            Date: (new Date()).toJSON().split('T')[0],
-            Language: 'eng',
-        };
-        metadata = Object.assign(metadataDefaults, metadata);
-        try {
-            var statRes = fs_1.statSync(this.tmpDir);
-            console.info("Tmp directory already exists, deleting [" + this.tmpDir + "]");
-            rimraf.sync(this.tmpDir);
-        }
-        catch (err) {
-            // noop
-        }
-        var _a = opts.welcome, welcome = _a === void 0 ? '' : _a, _b = opts.fullTextIndexLanguage, fullTextIndexLanguage = _b === void 0 ? '' : _b, _c = opts.minChunkSize, minChunkSize = _c === void 0 ? 2048 : _c;
-        this._creator = new zim_1.ZimCreatorWrapper({
-            fileName: this.fileName,
-            mainPage: welcome,
-            compression: this.compression,
-            fullTextIndexLanguage: fullTextIndexLanguage,
-            minChunkSize: minChunkSize
-        });
-        this.setMetadata(metadata);
-    }
-    Object.defineProperty(ZimCreator.prototype, "isAlive", {
-        get: function () {
-            return !!this._creator;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ZimCreator.prototype.addArticle = function (article) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!this.isAlive)
-                            throw new Error("This Creator has been destroyed");
-                        if (!article.mimeType)
-                            article.mimeType = mime.getType(article.url) || 'text/plain';
-                        return [4 /*yield*/, this._creator.addArticle(article)];
-                    case 1:
-                        _b.sent();
-                        if (!article.redirectUrl) {
-                            this.articleCounter[article.mimeType] = (_a = this.articleCounter[article.mimeType]) !== null && _a !== void 0 ? _a : 0;
-                            this.articleCounter[article.mimeType] += 1;
-                        }
-                        return [2 /*return*/, article];
-                }
-            });
-        });
-    };
-    ZimCreator.prototype.setMetadata = function (metadata) {
-        return __awaiter(this, void 0, void 0, function () {
-            var keys, _i, keys_1, key, content, article;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.isAlive)
-                            throw new Error("This Creator has been destroyed");
-                        keys = Object.keys(metadata).filter(function (key) { return metadata[key]; });
-                        _i = 0, keys_1 = keys;
-                        _a.label = 1;
-                    case 1:
-                        if (!(_i < keys_1.length)) return [3 /*break*/, 4];
-                        key = keys_1[_i];
-                        content = metadata[key];
-                        article = new zim_1.ZimArticle({ url: key, data: content, ns: 'M' });
-                        return [4 /*yield*/, this.addArticle(article)];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    ZimCreator.prototype.finalise = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var counterString;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.isAlive)
-                            throw new Error("This Creator has been destroyed");
-                        counterString = Object.keys(this.articleCounter)
-                            .map(function (mimeType) { return mimeType + "=" + _this.articleCounter[mimeType]; })
-                            .join(';');
-                        return [4 /*yield*/, this.setMetadata({ Counter: counterString })];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this._creator.finalise()];
-                    case 2:
-                        _a.sent();
-                        this._creator = null;
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return ZimCreator;
-}());
-exports.ZimCreator = ZimCreator;