@openzim/libzim 3.4.0 → 4.0.0

package/src/illustration.h

@@ -0,0 +1,167 @@
+#pragma once
+
+#include <napi.h>
+#include <zim/illustration.h>
+
+#include <exception>
+#include <map>
+#include <string>
+
+class IllustrationInfo : public Napi::ObjectWrap<IllustrationInfo> {
+ public:
+  explicit IllustrationInfo(const Napi::CallbackInfo &info)
+      : Napi::ObjectWrap<IllustrationInfo>(info), ii_{} {
+    Napi::Env env = info.Env();
+
+    if (info.Length() == 0) {
+      // Default constructor
+      ii_ = zim::IllustrationInfo{};
+      return;
+    }
+
+    // IllustrationInfo(ii: External<zim::IllustrationInfo>)
+    // Construct from external, used internally
+    if (info[0].IsExternal()) {
+      auto ext = info[0].As<Napi::External<zim::IllustrationInfo>>();
+      ii_ = *(ext.Data());
+      return;
+    }
+
+    if (!info[0].IsObject()) {
+      throw Napi::Error::New(env,
+                             "IllustrationInfo constructor expects an "
+                             "IllustrationInfo like object");
+    }
+
+    auto value = info[0];
+    // IllustrationInfo(ii: IllustrationInfo)
+    // Copy constructor
+    if (InstanceOf(env, value)) {
+      auto unwrapped = Unwrap(value.As<Napi::Object>());
+      ii_ = zim::IllustrationInfo(unwrapped->ii_);
+      return;
+    }
+
+    // IllustrationInfo(ii: object)
+    // Construct from object
+    ii_ = infoFrom(value.As<Napi::Object>());
+  }
+
+  static Napi::Object New(Napi::Env env, const zim::IllustrationInfo &ii) {
+    Napi::FunctionReference &constructor = GetConstructor(env);
+    auto data = Napi::External<zim::IllustrationInfo>::New(
+        env, new zim::IllustrationInfo(ii),
+        [](Napi::BasicEnv /*env*/, zim::IllustrationInfo *ptr) { delete ptr; });
+    return constructor.New({data});
+  }
+
+  /**
+   * Construct zim::IllustrationInfo from a JS object
+   */
+  static zim::IllustrationInfo infoFrom(Napi::Object obj) {
+    zim::IllustrationInfo ii{
+        .width =
+            obj.Has("width") ? obj.Get("width").ToNumber().Uint32Value() : 0,
+        .height =
+            obj.Has("height") ? obj.Get("height").ToNumber().Uint32Value() : 0,
+        .scale =
+            obj.Has("scale") ? obj.Get("scale").ToNumber().FloatValue() : 0.0f,
+        .extraAttributes = std::map<std::string, std::string>{},
+    };
+
+    if (obj.Has("extraAttributes") && obj.Get("extraAttributes").IsObject()) {
+      auto extraAttributes = obj.Get("extraAttributes").ToObject();
+      auto keys = extraAttributes.GetPropertyNames();
+      for (const auto &e : keys) {
+        auto key =
+            static_cast<Napi::Value>(e.second).As<Napi::String>().Utf8Value();
+        auto value = extraAttributes.Get(key).ToString().Utf8Value();
+        ii.extraAttributes[key] = value;
+      }
+    }
+
+    return ii;
+  }
+
+  Napi::Value getWidth(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    return Napi::Value::From(env, ii_.width);
+  }
+
+  Napi::Value getHeight(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    return Napi::Value::From(env, ii_.height);
+  }
+
+  Napi::Value getScale(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    return Napi::Value::From(env, ii_.scale);
+  }
+
+  Napi::Value getExtraAttributes(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    Napi::Object obj = Napi::Object::New(env);
+    for (const auto &pair : ii_.extraAttributes) {
+      obj.Set(pair.first, pair.second);
+    }
+    obj.Freeze();
+    return obj;
+  }
+
+  Napi::Value asMetadataItemName(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    return Napi::Value::From(env, ii_.asMetadataItemName());
+  }
+
+  static Napi::Value fromMetadataItemName(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsString()) {
+      throw Napi::TypeError::New(
+          env, "First argument must be a string for metadata item name.");
+    }
+
+    auto name = info[0].As<Napi::String>().Utf8Value();
+    auto ii = zim::IllustrationInfo::fromMetadataItemName(name);
+    return New(env, ii);
+  }
+
+  static bool InstanceOf(Napi::Env env, Napi::Value value) {
+    if (!value.IsObject()) {
+      return false;
+    }
+    Napi::Object obj = value.As<Napi::Object>();
+    Napi::FunctionReference &constructor = GetConstructor(env);
+    return obj.InstanceOf(constructor.Value());
+  }
+
+  static Napi::FunctionReference &GetConstructor(Napi::Env env) {
+    auto constructors = env.GetInstanceData<ModuleConstructors>();
+    return constructors->illustrationInfo;
+  }
+
+  zim::IllustrationInfo &getInternalIllustrationInfo() { return ii_; }
+
+  static void Init(Napi::Env env, Napi::Object exports,
+                   ModuleConstructors &constructors) {
+    Napi::Function func = DefineClass(
+        env, "IllustrationInfo",
+        {
+            InstanceAccessor<&IllustrationInfo::getWidth>("width"),
+            InstanceAccessor<&IllustrationInfo::getHeight>("height"),
+            InstanceAccessor<&IllustrationInfo::getScale>("scale"),
+            InstanceAccessor<&IllustrationInfo::getExtraAttributes>(
+                "extraAttributes"),
+            InstanceMethod<&IllustrationInfo::asMetadataItemName>(
+                "asMetadataItemName"),
+            StaticMethod<&IllustrationInfo::fromMetadataItemName>(
+                "fromMetadataItemName"),
+        });
+
+    exports.Set("IllustrationInfo", func);
+    constructors.illustrationInfo = Napi::Persistent(func);
+  }
+
+ private:
+  zim::IllustrationInfo ii_;
+};
+

package/src/index.d.ts

@@ -1,3 +1,7 @@
+export declare function getClusterCacheMaxSize(): number;
+export declare function getClusterCacheCurrentSize(): number;
+export declare function setClusterCacheMaxSize(nbClusters: number): void;
+
 export class IntegrityCheck {
   static CHECKSUM: symbol;
   static DIRENT_PTRS: symbol;
@@ -104,7 +108,10 @@ export class Creator {
     content: string | ContentProvider,
     mimetype?: string,
   ): void;
-  addIllustration(size: number, content: string | ContentProvider): void;
+  addIllustration(
+    sizeOrInfo: number | IIllustrationInfo,
+    content: string | ContentProvider,
+  ): void;
   addRedirection(
     path: string,
     title: string,
@@ -146,8 +153,35 @@ export interface EntryRange extends Iterable<Entry> {
   offset(start: number, maxResults: number): EntryRange;
 }
 
+export interface IIllustrationInfo {
+  width?: number;
+  height?: number;
+  scale?: number;
+  extraAttributes?: Record<string, string>;
+}
+
+export class IllustrationInfo implements IIllustrationInfo {
+  constructor(info?: IIllustrationInfo | IllustrationInfo);
+  get width(): number;
+  get height(): number;
+  get scale(): number;
+  get extraAttributes(): Record<string, string>;
+  asMetadataItemName(): string;
+  static fromMetadataItemName(name: string): IllustrationInfo;
+}
+
+export class OpenConfig {
+  constructor();
+
+  preloadXapianDb(preload: boolean): this;
+  preloadDirentRanges(nbRanges: number): this;
+
+  get m_preloadXapianDb(): boolean;
+  get m_preloadDirentRanges(): number;
+}
+
 export class Archive {
-  constructor(filepath: string);
+  constructor(filepath: string, config?: OpenConfig);
   get filename(): string;
   get filesize(): number | bigint;
   get allEntryCount(): number;
@@ -158,8 +192,14 @@ export class Archive {
   getMetadata(name: string): string;
   getMetadataItem(name: string): Item;
   get metadataKeys(): string[];
-  getIllustrationItem(size: number): Item;
+  getIllustrationItem(sizeOrInfo?: number | IIllustrationInfo): Item;
   get illustrationSizes(): Set<number>;
+  getIllustrationInfos(
+    width?: number,
+    height?: number,
+    minScale?: number,
+  ): IllustrationInfo[];
+  get illustrationInfos(): IllustrationInfo[];
   getEntryByPath(path_or_idx: string | number): Entry;
   getEntryByTitle(title_or_idx: string | number): Entry;
   getEntryByClusterOrder(idx: number): Entry;
@@ -182,14 +222,9 @@ export class Archive {
   checkIntegrity(checkType: symbol): boolean; // one of IntegrityCheck
   get isMultiPart(): boolean;
   get hasNewNamespaceScheme(): boolean;
-  getClusterCacheMaxSize(): number;
-  getClusterCacheCurrentSize(): number;
-  setClusterCacheMaxSize(nbClusters: number): void;
   getDirentCacheMaxSize(): number;
   getDirentCacheCurrentSize(): number;
   setDirentCacheMaxSize(nbDirents: number): void;
-  getDirentLookupCacheMaxSize(): number;
-  setDirentLookupCacheMaxSize(nbRanges: number): void;
 
   static validate(zimPath: string, checksToRun: symbol[]): boolean; // list of IntegrityCheck
 }

package/src/index.js

@@ -2,9 +2,11 @@ import bindings from "bindings";
 
 export const {
   Archive,
+  OpenConfig,
   Entry,
   IntegrityCheck,
   Compression,
+  IllustrationInfo,
   Blob,
   Searcher,
   Query,
@@ -14,4 +16,7 @@ export const {
   FileProvider,
   StringItem,
   FileItem,
+  getClusterCacheMaxSize,
+  getClusterCacheCurrentSize,
+  setClusterCacheMaxSize,
 } = bindings("zim_binding");

package/src/item.h

@@ -12,7 +12,6 @@ class Item : public Napi::ObjectWrap<Item> {
   explicit Item(const Napi::CallbackInfo &info)
       : Napi::ObjectWrap<Item>(info), item_{nullptr} {
     Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
 
     if (!info[0].IsExternal()) {
       throw Napi::Error::New(
@@ -108,10 +107,12 @@ class Item : public Napi::ObjectWrap<Item> {
   Napi::Value getDirectAccessInformation(const Napi::CallbackInfo &info) {
     try {
       auto env = info.Env();
-      const auto valPair = item_->getDirectAccessInformation();
+      const auto dai = item_->getDirectAccessInformation();
       auto res = Napi::Object::New(env);
-      res["filename"] = Napi::Value::From(env, valPair.first);
-      res["offset"] = Napi::Value::From(env, valPair.second);
+      res["filename"] = Napi::Value::From(env, dai.filename);
+      res["offset"] = Napi::Value::From(env, dai.offset);
+      res["isValid"] = Napi::Value::From(env, dai.isValid());
+      res.Freeze();
       return res;
     } catch (const std::exception &err) {
       throw Napi::Error::New(info.Env(), err.what());
@@ -128,7 +129,6 @@ class Item : public Napi::ObjectWrap<Item> {
 
   static void Init(Napi::Env env, Napi::Object exports,
                    ModuleConstructors &constructors) {
-    Napi::HandleScope scope(env);
     Napi::Function func =
         DefineClass(env, "Item",
                     {

package/src/module.cc

@@ -7,7 +7,9 @@
 #include "contentProvider.h"
 #include "creator.h"
 #include "entry.h"
+#include "illustration.h"
 #include "item.h"
+#include "openconfig.h"
 #include "search.h"
 #include "suggestion.h"
 #include "writerItem.h"
@@ -26,6 +28,8 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
   Item::Init(env, exports, *constructors);
   Entry::Init(env, exports, *constructors);
   Archive::Init(env, exports, *constructors);
+  OpenConfig::Init(env, exports, *constructors);
+  IllustrationInfo::Init(env, exports, *constructors);
 
   Searcher::Init(env, exports, *constructors);
   Query::Init(env, exports, *constructors);
@@ -45,6 +49,28 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
   StringItem::Init(env, exports, *constructors);
   FileItem::Init(env, exports, *constructors);
 
+  // Extra helper functions from libzim
+  exports.Set("getClusterCacheMaxSize",
+              Napi::Function::New(env, [](const Napi::CallbackInfo &info) {
+                return Napi::Value::From(info.Env(),
+                                         zim::getClusterCacheMaxSize());
+              }));
+  exports.Set("getClusterCacheCurrentSize",
+              Napi::Function::New(env, [](const Napi::CallbackInfo &info) {
+                return Napi::Value::From(info.Env(),
+                                         zim::getClusterCacheCurrentSize());
+              }));
+  exports.Set("setClusterCacheMaxSize",
+              Napi::Function::New(env, [](const Napi::CallbackInfo &info) {
+                if (info.Length() < 1 || !info[0].IsNumber()) {
+                  throw Napi::TypeError::New(
+                      info.Env(),
+                      "First argument must be a number for max size.");
+                }
+                auto size = info[0].As<Napi::Number>().Int64Value();
+                zim::setClusterCacheMaxSize(size);
+              }));
+
   return exports;
 }
 

package/src/openconfig.h

@@ -0,0 +1,83 @@
+#pragma once
+
+#include <napi.h>
+#include <zim/zim.h>
+
+class OpenConfig : public Napi::ObjectWrap<OpenConfig> {
+ public:
+  explicit OpenConfig(const Napi::CallbackInfo& info)
+      : Napi::ObjectWrap<OpenConfig>(info), config_{zim::OpenConfig()} {
+    if (info.Length() > 0) {
+      throw Napi::Error::New(
+          info.Env(), "OpenConfig constructor does not take any arguments.");
+    }
+  }
+
+  Napi::Value preloadXapianDb(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsBoolean()) {
+      throw Napi::TypeError::New(
+          env, "First argument must be a boolean for preloadXapianDb.");
+    }
+    bool value = info[0].As<Napi::Boolean>().Value();
+    config_.preloadXapianDb(value);
+    return info.This();
+  }
+
+  Napi::Value preloadDirentRanges(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+      throw Napi::TypeError::New(
+          env, "First argument must be a number for preloadDirentRanges.");
+    }
+    int value = info[0].As<Napi::Number>().Int32Value();
+    config_.preloadDirentRanges(value);
+    return info.This();
+  }
+
+  Napi::Value getPreloadXapianDb(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    return Napi::Value::From(env, config_.m_preloadXapianDb);
+  }
+
+  Napi::Value getPreloadDirentRanges(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    return Napi::Value::From(env, config_.m_preloadDirentRanges);
+  }
+
+  static Napi::FunctionReference& GetConstructor(Napi::Env env) {
+    return env.GetInstanceData<ModuleConstructors>()->openConfig;
+  }
+
+  static bool InstanceOf(Napi::Env env, Napi::Value value) {
+    if (!value.IsObject()) {
+      return false;
+    }
+    Napi::Object obj = value.As<Napi::Object>();
+    Napi::FunctionReference& constructor = GetConstructor(env);
+    return obj.InstanceOf(constructor.Value());
+  }
+
+  const zim::OpenConfig& getInternalConfig() const { return config_; }
+
+  static void Init(Napi::Env env, Napi::Object exports,
+                   ModuleConstructors& constructors) {
+    Napi::Function func = DefineClass(
+        env, "OpenConfig",
+        {
+            InstanceMethod<&OpenConfig::preloadXapianDb>("preloadXapianDb"),
+            InstanceMethod<&OpenConfig::preloadDirentRanges>(
+                "preloadDirentRanges"),
+            InstanceAccessor<&OpenConfig::getPreloadXapianDb>(
+                "m_preloadXapianDb"),
+            InstanceAccessor<&OpenConfig::getPreloadDirentRanges>(
+                "m_preloadDirentRanges"),
+        });
+
+    exports.Set("OpenConfig", func);
+    constructors.openConfig = Napi::Persistent(func);
+  }
+
+ private:
+  zim::OpenConfig config_;
+};

package/src/search.h

@@ -118,7 +118,6 @@ class Query : public Napi::ObjectWrap<Query> {
 
   static void Init(Napi::Env env, Napi::Object exports,
                    ModuleConstructors &constructors) {
-    Napi::HandleScope scope(env);
     Napi::Function func = DefineClass(
         env, "Query",
         {
@@ -144,9 +143,6 @@ class SearchIterator : public Napi::ObjectWrap<SearchIterator> {
  public:
   explicit SearchIterator(const Napi::CallbackInfo &info)
       : Napi::ObjectWrap<SearchIterator>(info), searchIterator_{} {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-
     if (info[0].IsExternal()) {
       searchIterator_ =
           *info[0].As<Napi::External<zim::SearchIterator>>().Data();
@@ -233,7 +229,6 @@ class SearchIterator : public Napi::ObjectWrap<SearchIterator> {
 
   static void Init(Napi::Env env, Napi::Object exports,
                    ModuleConstructors &constructors) {
-    Napi::HandleScope scope(env);
     Napi::Function func = DefineClass(
         env, "SearchIterator",
         {
@@ -260,7 +255,6 @@ class SearchResultSet : public Napi::ObjectWrap<SearchResultSet> {
   explicit SearchResultSet(const Napi::CallbackInfo &info)
       : Napi::ObjectWrap<SearchResultSet>(info), searchResultSet_{nullptr} {
     Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
 
     if (!info[0].IsExternal()) {
       throw Napi::Error::New(env,
@@ -326,7 +320,6 @@ class SearchResultSet : public Napi::ObjectWrap<SearchResultSet> {
 
   static void Init(Napi::Env env, Napi::Object exports,
                    ModuleConstructors &constructors) {
-    Napi::HandleScope scope(env);
     Napi::Function func =
         DefineClass(env, "SearchResultSet",
                     {
@@ -347,11 +340,8 @@ class Search : public Napi::ObjectWrap<Search> {
  public:
   explicit Search(const Napi::CallbackInfo &info)
       : Napi::ObjectWrap<Search>(info), search_{nullptr} {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-
     if (!info[0].IsExternal()) {
-      throw Napi::Error::New(env, "Search must be created internally.");
+      throw Napi::Error::New(info.Env(), "Search must be created internally.");
     }
 
     search_ = std::make_shared<zim::Search>(
@@ -393,7 +383,6 @@ class Search : public Napi::ObjectWrap<Search> {
 
   static void Init(Napi::Env env, Napi::Object exports,
                    ModuleConstructors &constructors) {
-    Napi::HandleScope scope(env);
     Napi::Function func = DefineClass(
         env, "Search",
         {
@@ -414,7 +403,6 @@ class Searcher : public Napi::ObjectWrap<Searcher> {
   explicit Searcher(const Napi::CallbackInfo &info)
       : Napi::ObjectWrap<Searcher>(info), searcher_{nullptr} {
     Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
 
     if (info[0].IsArray()) {
       auto array = info[0].As<Napi::Array>();
@@ -499,7 +487,6 @@ class Searcher : public Napi::ObjectWrap<Searcher> {
 
   static void Init(Napi::Env env, Napi::Object exports,
                    ModuleConstructors &constructors) {
-    Napi::HandleScope scope(env);
     Napi::Function func =
         DefineClass(env, "Searcher",
                     {

package/src/suggestion.h

@@ -17,9 +17,6 @@ class SuggestionIterator : public Napi::ObjectWrap<SuggestionIterator> {
  public:
   explicit SuggestionIterator(const Napi::CallbackInfo &info)
       : Napi::ObjectWrap<SuggestionIterator>(info), iterator_{} {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-
     if (info[0].IsExternal()) {
       iterator_ = *info[0].As<Napi::External<decltype(iterator_)>>().Data();
     }
@@ -75,7 +72,6 @@ class SuggestionIterator : public Napi::ObjectWrap<SuggestionIterator> {
 
   static void Init(Napi::Env env, Napi::Object exports,
                    ModuleConstructors &constructors) {
-    Napi::HandleScope scope(env);
     Napi::Function func = DefineClass(
         env, "SuggestionIterator",
         {
@@ -99,7 +95,6 @@ class SuggestionResultSet : public Napi::ObjectWrap<SuggestionResultSet> {
   explicit SuggestionResultSet(const Napi::CallbackInfo &info)
       : Napi::ObjectWrap<SuggestionResultSet>(info), resultSet_{nullptr} {
     Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
 
     if (!info[0].IsExternal()) {
       throw Napi::Error::New(env,
@@ -163,7 +158,6 @@ class SuggestionResultSet : public Napi::ObjectWrap<SuggestionResultSet> {
 
   static void Init(Napi::Env env, Napi::Object exports,
                    ModuleConstructors &constructors) {
-    Napi::HandleScope scope(env);
     Napi::Function func =
         DefineClass(env, "SuggestionResultSet",
                     {
@@ -185,7 +179,6 @@ class SuggestionSearch : public Napi::ObjectWrap<SuggestionSearch> {
   explicit SuggestionSearch(const Napi::CallbackInfo &info)
       : Napi::ObjectWrap<SuggestionSearch>(info), search_{nullptr} {
     Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
 
     if (!info[0].IsExternal()) {
       throw Napi::Error::New(env, "Search must be created internally.");
@@ -232,7 +225,6 @@ class SuggestionSearch : public Napi::ObjectWrap<SuggestionSearch> {
 
   static void Init(Napi::Env env, Napi::Object exports,
                    ModuleConstructors &constructors) {
-    Napi::HandleScope scope(env);
     Napi::Function func = DefineClass(
         env, "SuggestionSearch",
         {
@@ -255,7 +247,6 @@ class SuggestionSearcher : public Napi::ObjectWrap<SuggestionSearcher> {
       : Napi::ObjectWrap<SuggestionSearcher>(info),
         suggestionSearcher_{nullptr} {
     Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
 
     // TODO(kelvinhammond): Ask about support for suggestions from multiple
     // archives
@@ -340,7 +331,6 @@ class SuggestionSearcher : public Napi::ObjectWrap<SuggestionSearcher> {
 
   static void Init(Napi::Env env, Napi::Object exports,
                    ModuleConstructors &constructors) {
-    Napi::HandleScope scope(env);
     Napi::Function func = DefineClass(
         env, "SuggestionSearcher",
         {