@sillsdev/docu-notion 0.12.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 SIL International
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,135 @@
+# docu-notion
+
+docu-notion lets you use Notion as your editor for [Docusaurus](https://docusaurus.io/). Using Notion instead of raw markdown files means that you don't have to teach non-developers how to make git commits and pull requests. It also allows you to leverage Notion's database tools to control workflow, Notion's commenting feature to discuss changes, etc.
+
+Example Site: https://sillsdev.github.io/docu-notion-sample-site/
+
+# Instructions
+
+## 1. Set up your documentation site.
+
+First, prepare your markdown-based static file system like [Docusaurus](https://docusaurus.io/). For a shortcut with github actions, search, and deployment to github pages, you can just copy [this template](https://github.com/sillsdev/docu-notion-sample-site).
+
+## 2. In Notion, duplicate the docu-notion template
+
+Go to [this template page](https://hattonjohn.notion.site/Documentation-Template-Docusaurus-0e998b32da3c47edad0f62a25b49818c). Duplicate it into your own workspace.
+You can name it anything you like, e.g. "Documentation Root".
+
+## 3. Create a Notion Integration
+
+In order for docu-notion to read your site via Notion's API, you need to create what Notion calls an "integration". Follow [these instructions](https://developers.notion.com/docs/getting-started) to make an integration and get your token. Limit your integration to "READ" access.
+
+## 4. "Invite" your Notion Integration to read you page
+
+In Notion, click "Share" on the root of your documentation and "invite" your integration to it.
+
+![image](https://user-images.githubusercontent.com/8448/168930238-1dcf46df-a690-4839-bf4c-c63157f104d8.png)
+
+## 5. Add your pages under your Outline page.
+
+Currently, docu-notion expects that each page has only one of the following: sub-pages, links to other pages, or normal content. Do not mix them. You can add content pages directly here, but then you won't be able to make use of the workflow features. If those matter to you, instead make new pages under the "Database" and then link to them in your outline pages.
+
+## 6. Pull your pages
+
+First, determine the id of your root page by clicking "Share" and looking at the the url it gives you. E.g.
+https://www.notion.so/hattonjohn/My-Docs-0456aa5842946bdbea3a4f37c97a0e5
+means that the id is "0456aa5842946PRETEND4f37c97a0e5".
+
+Determine where you want the markdown files and images to land. The following works well for Docusaurus instances:
+
+```
+npx docu-notion -n secret_PRETEND123456789PRETEND123456789PRETEND6789 -r 0456aa5842946PRETEND4f37c97a0e5"
+```
+
+Likely, you will want to store these codes in your environment variables and then use them like this:
+
+```
+(windows)
+npx docu-notion -n %MY_NOTION_TOKEN% -r %MY_NOTION_DOCS_ROOT_PAGE_ID%
+```
+
+```
+(linux / mac)
+npx docu-notion -n $MY_NOTION_TOKEN -r $MY_NOTION_DOCS_ROOT_PAGE_ID
+```
+
+NOTE: In the above, we are using `npx` to use the latest `docu-notion`. A more conservative approach would be to `npm i cross-var docu-notion` and then create a script in your package.json like this:
+
+```
+ "scripts": {
+     "pull": "cross-var docu-notion -n %DOCU_NOTION_INTEGRATION_TOKEN% -r %DOCU_NOTION_ROOT_PAGE%"
+  }
+```
+
+and then run that with `npm run pull`.
+
+## 7. Commit
+
+Most projects should probably commit the current markdown and image files each time you run docu-notion.
+
+Note that if you choose not to commit, the workflow feature (see below) won't work for you. Imagine the case where a document that previously had a `Status` property of `Publish` now has a different status. You probably want to keep publishing the old version until the new one is ready. But if you don't commit files, your CI system (e.g. Github Actions) won't have the old version around, so it will disappear from your site.
+
+# Using a Notion database for workflow
+
+One of the big attractions of Notion for large documentation projects is that you can treat your pages as database items. The advantage of this is that they can then have metadata properties that fit your workflow. For example, we use a simple kanban board view to see where each page is in our workflow:
+
+![image](https://user-images.githubusercontent.com/8448/168929745-e6529375-bb1e-47e9-b8a6-7a1467c8900f.png)
+
+`docu-notion` supports this by letting you link to database pages from your outline.
+
+![image](https://user-images.githubusercontent.com/8448/168929668-f83d7c86-75d2-48e9-940c-84c5268a2854.png)
+
+# Page properties
+
+![image](https://user-images.githubusercontent.com/8448/197016100-ab016111-2fa1-420a-a884-05318783096e.png)
+
+> **Note**
+> For some reason Notion only allows properties on pages that are part of a database. So if you create pages directly in the Outline, you won't be able to fill in any of these properties, other than the page title.
+
+## Slugs
+
+By default, pages will be given a slug based on the Notion id. For a human-readable URL, add a notion property named `Slug` to your database pages and enter a value in there that will work well in a URL. That is, no spaces, ?, #, /, etc.
+
+## Known Limitations
+
+docu-notion is not doing anything smart with regards to previously Published but now not Published documents. All it does is ignore every Notion document that doesn't have `status == Publish`. So if the old version of the document is still in your file tree when your static site generator (e.g. Docusaurus) runs, then it will appear on your website. If it isn't there, it won't. If you rename directories or move the document, docu-notion will not realize this and will delete the previously published markdown file.
+
+# Text Localization
+
+Localize your files in Crowdin (or whatever) based on the markdown files, not in Notion. For how to do this with Docusaurus, see [Docusaurus i18n](https://docusaurus.io/docs/i18n/crowdin).
+
+# Screenshot Localization
+
+The only way we know of to provide localization of image in the current Docusaurus (2.0) is to place the images in the same directory as the markdown, and use relative paths for images. Most projects probably won't localize _every_ image, so we also need a way to "fall back" to the original screenshot when the localized one is missing. `docu-notion` facilitates this. If no localized version of an image is available, `docu-notion` places a copy of the original image into the correct location.
+
+So how do you provide these localized screenshot files? Crowdin can handle localizing assets, and in the future we may support that. For now, we currently support a different approach. If you place for example `fr https:\\imgur.com\1234.png` in the caption of a screenshot in Notion, `docu-notion` will fetch that image and save it in the right place to be found when in French mode. Getting URLs to screenshots is easy with screenshot utilities such as [Greenshot](https://getgreenshot.org/) that support uploading to imgur. Note that `docu-notion` stores a copy of all images in your source tree, so you wouldn't lose the images if imgur were to go away.
+
+NOTE: that as far as I can tell, when you run `docusaurus start` docusaurus 2.0 offers the language picker but it doesn't actually work. So to test out the localized version, do `docusaurus build` followed by `docusaurus serve`.
+
+NOTE: if you just localize an image, it will not get picked up. You also must localize the page that uses the image. Otherwise, Docusaurus will use the English document and when that asks for `./the-image-path`, it will find the image there in the English section, not your other language section.
+
+# Automated builds with Github Actions
+
+Here is a working Github Action script to copy and customize: https://github.com/BloomBooks/bloom-docs/blob/master/.github/workflows/release.yml
+
+# Command line
+
+Usage: docu-notion -n <token> -r <root> [options]
+
+Options:
+
+| flag                                  | required? | description                                                                                                                                                                                                        |
+| ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| -n, --notion-token <string>           | required  | notion api token, which looks like `secret_3bc1b50XFYb15123RHF243x43450XFY33250XFYa343`                                                                                                                            |
+| -r, --root-page <string>              | required  | The 31 character ID of the page which is the root of your docs page in notion. The code will look like `9120ec9960244ead80fa2ef4bc1bba25`. This page must have a child page named 'Outline'                        |
+| -m, --markdown-output-path <string>   |           | Root of the hierarchy for md files. WARNING: node-pull-mdx will delete files from this directory. Note also that if it finds localized images, it will create an i18n/ directory as a sibling. (default: "./docs") |
+| -t, --status-tag <string>             |           | Database pages without a Notion page property 'status' matching this will be ignored. Use '\*' to ignore status altogether. (default: `Publish`)                                                                   |
+| --locales <codes>                     |           | Comma-separated list of iso 639-2 codes, the same list as in docusaurus.config.js, minus the primary (i.e. 'en'). This is needed for image localization. (default: [])                                             |
+| -l, --log-level <level>               |           | Log level (choices: `info`, `verbose`, `debug`)                                                                                                                                                                    |
+| -i, --img-output-path <string>        |           | Path to directory where images will be stored. If this is not included, images will be placed in the same directory as the document that uses them, which then allows for localization of screenshots.             |
+| -p, --img-prefix-in-markdown <string> |           | When referencing an image from markdown, prefix with this path instead of the full img-output-path. Should be used only in conjunction with --img-output-path.                                                     |
+| -h, --help                            |           | display help for command                                                                                                                                                                                           |
+
+# Plugins
+
+If your project needs some processing that docu-notion doesn't already provide, you can provide a plugin that does it. See the [plugin readme](src/plugins/README.md).

package/dist/FlatGuidLayoutStrategy.d.ts

@@ -0,0 +1,6 @@
+import { LayoutStrategy } from "./LayoutStrategy";
+import { NotionPage } from "./NotionPage";
+export declare class FlatGuidLayoutStrategy extends LayoutStrategy {
+    newLevel(rootDir: string, order: number, context: string, _levelLabel: string): string;
+    getPathForPage(page: NotionPage, extensionWithDot: string): string;
+}

package/dist/FlatGuidLayoutStrategy.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlatGuidLayoutStrategy = void 0;
+const LayoutStrategy_1 = require("./LayoutStrategy");
+// This strategy creates a flat list of files that have notion-id for file names.
+// Pros: the urls will never change so long as the notion pages are not delete and re-recreated.
+// Cons: the names are human readable, so:
+//    * troubleshooting is more difficult
+//    * is less "future" proof, in the sense that if you someday take these files and move them
+//    * to a new system, maybe you will wish the files had names.
+// TODO: for this to be viable, we'd also have to emit info on how to build the sidebar, because
+// the directory/file structure itself is no longer representative of the outline we want.
+class FlatGuidLayoutStrategy extends LayoutStrategy_1.LayoutStrategy {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    newLevel(rootDir, order, context, _levelLabel) {
+        // In this strategy, we ignore context and don't create any directories to match the levels.
+        // Just return the following for the benefit of logging.
+        return context + "/" + _levelLabel;
+    }
+    getPathForPage(page, extensionWithDot) {
+        // In this strategy, we don't care about the location or the title
+        return this.rootDirectory + "/" + page.pageId + extensionWithDot;
+    }
+}
+exports.FlatGuidLayoutStrategy = FlatGuidLayoutStrategy;

package/dist/HierarchicalNamedLayoutStrategy.d.ts

@@ -0,0 +1,7 @@
+import { LayoutStrategy } from "./LayoutStrategy";
+import { NotionPage } from "./NotionPage";
+export declare class HierarchicalNamedLayoutStrategy extends LayoutStrategy {
+    newLevel(dirRoot: string, order: number, context: string, levelLabel: string): string;
+    getPathForPage(page: NotionPage, extensionWithDot: string): string;
+    private addCategoryMetadata;
+}

package/dist/HierarchicalNamedLayoutStrategy.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HierarchicalNamedLayoutStrategy = void 0;
+const fs = __importStar(require("fs-extra"));
+const sanitize_filename_1 = __importDefault(require("sanitize-filename"));
+const LayoutStrategy_1 = require("./LayoutStrategy");
+// This strategy gives us a file tree that mirrors that of notion.
+// Each level in the outline becomes a directory, and each file bears the name of the Notion document.
+// As long as you use slugs, the urls is still just something like https://site/slug
+class HierarchicalNamedLayoutStrategy extends LayoutStrategy_1.LayoutStrategy {
+    newLevel(dirRoot, order, context, levelLabel) {
+        const path = context + "/" + (0, sanitize_filename_1.default)(levelLabel).replaceAll(" ", "-");
+        //console.log("Creating level " + path);
+        const newPath = dirRoot + "/" + path;
+        fs.mkdirSync(newPath, { recursive: true });
+        this.addCategoryMetadata(newPath, order, levelLabel);
+        return path;
+    }
+    getPathForPage(page, extensionWithDot) {
+        const sanitizedName = (0, sanitize_filename_1.default)(page.nameForFile())
+            .replaceAll("//", "/")
+            .replaceAll("%20", "-")
+            .replaceAll(" ", "-")
+            // crowdin complains about some characters in file names. I haven't found
+            // the actual list, so these are from memory.
+            .replaceAll('"', "")
+            .replaceAll("“", "")
+            .replaceAll("”", "")
+            .replaceAll("'", "")
+            .replaceAll("?", "-");
+        const context = ("/" + page.layoutContext + "/").replaceAll("//", "/");
+        const path = this.rootDirectory + context + sanitizedName + extensionWithDot;
+        return path;
+    }
+    //{
+    //   "position": 2.5,
+    //   "label": "Tutorial",
+    //   "collapsible": true,
+    //   "collapsed": false,
+    //   "className": "red",
+    //   "link": {
+    //     "type": "generated-index",
+    //     "title": "Tutorial overview"
+    //   },
+    //   "customProps": {
+    //     "description": "This description can be used in the swizzled DocCard"
+    //   }
+    // }
+    addCategoryMetadata(dir, order, label) {
+        const data = `{"position":${order}, "label":"${label}"}`;
+        fs.writeFileSync(dir + "/_category_.json", data);
+    }
+}
+exports.HierarchicalNamedLayoutStrategy = HierarchicalNamedLayoutStrategy;

package/dist/LayoutStrategy.d.ts

@@ -0,0 +1,12 @@
+import { NotionPage } from "./NotionPage";
+export declare abstract class LayoutStrategy {
+    protected rootDirectory: string;
+    protected existingPagesNotSeenYetInPull: string[];
+    setRootDirectoryForMarkdown(markdownOutputPath: string): void;
+    cleanupOldFiles(): Promise<void>;
+    abstract newLevel(rootDir: string, order: number, context: string, levelLabel: string): string;
+    abstract getPathForPage(page: NotionPage, extensionWithDot: string): string;
+    getLinkPathForPage(page: NotionPage): string;
+    pageWasSeen(page: NotionPage): void;
+    protected getListOfExistingFiles(dir: string): string[];
+}

package/dist/LayoutStrategy.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.prototype.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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LayoutStrategy = void 0;
+const fs = __importStar(require("fs-extra"));
+const log_1 = require("./log");
+// Here a fuller name would be File Tree Layout Strategy. That is,
+// as we walk the Notion outline and create files, where do we create them, what do we name them, etc.
+class LayoutStrategy {
+    constructor() {
+        this.rootDirectory = "";
+        this.existingPagesNotSeenYetInPull = [];
+    }
+    setRootDirectoryForMarkdown(markdownOutputPath) {
+        this.rootDirectory = markdownOutputPath;
+        this.existingPagesNotSeenYetInPull =
+            this.getListOfExistingFiles(markdownOutputPath);
+    }
+    cleanupOldFiles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Remove any pre-existing files that aren't around anymore; this indicates that they were removed or renamed in Notion.
+            for (const p of this.existingPagesNotSeenYetInPull) {
+                (0, log_1.verbose)(`Removing old doc: ${p}`);
+                yield fs.rm(p);
+            }
+        });
+    }
+    getLinkPathForPage(page) {
+        // the url we return starts with a "/", meaning it is relative to the root of the markdown root (e.g. /docs root in Docusaurus)
+        return ("/" + page.slug).replaceAll("//", "/");
+    }
+    pageWasSeen(page) {
+        const path = this.getPathForPage(page, ".md");
+        this.existingPagesNotSeenYetInPull =
+            this.existingPagesNotSeenYetInPull.filter(p => p !== path);
+    }
+    getListOfExistingFiles(dir) {
+        return fs.readdirSync(dir).flatMap(item => {
+            const path = `${dir}/${item}`;
+            if (fs.statSync(path).isDirectory()) {
+                return this.getListOfExistingFiles(path);
+            }
+            if (path.endsWith(".md")) {
+                // we could just notice all files, and maybe that's better. But then we lose an debugging files like .json of the raw notion, on the second run.
+                return [path];
+            }
+            else
+                return [];
+        });
+    }
+}
+exports.LayoutStrategy = LayoutStrategy;

package/dist/MakeImagePersistencePlan.d.ts

@@ -0,0 +1,2 @@
+import { ImageSet } from "./images";
+export declare function makeImagePersistencePlan(imageSet: ImageSet, imageOutputRootPath: string, imagePrefix: string): void;

package/dist/MakeImagePersistencePlan.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeImagePersistencePlan = void 0;
+const Path = __importStar(require("path"));
+const log_1 = require("./log");
+const process_1 = require("process");
+function makeImagePersistencePlan(imageSet, imageOutputRootPath, imagePrefix) {
+    var _a;
+    if ((_a = imageSet.fileType) === null || _a === void 0 ? void 0 : _a.ext) {
+        // Since most images come from pasting screenshots, there isn't normally a filename. That's fine, we just make a hash of the url
+        // Images that are stored by notion come to us with a complex url that changes over time, so we pick out the UUID that doesn't change. Example:
+        //    https://s3.us-west-2.amazonaws.com/secure.notion-static.com/d1058f46-4d2f-4292-8388-4ad393383439/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45EIPT3X45%2F20220516%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20220516T233630Z&X-Amz-Expires=3600&X-Amz-Signature=f215704094fcc884d37073b0b108cf6d1c9da9b7d57a898da38bc30c30b4c4b5&X-Amz-SignedHeaders=host&x-id=GetObject
+        let thingToHash = imageSet.primaryUrl;
+        const m = /.*secure\.notion-static\.com\/(.*)\//gm.exec(imageSet.primaryUrl);
+        if (m && m.length > 1) {
+            thingToHash = m[1];
+        }
+        const hash = hashOfString(thingToHash);
+        imageSet.outputFileName = `${hash}.${imageSet.fileType.ext}`;
+        imageSet.primaryFileOutputPath = Path.posix.join((imageOutputRootPath === null || imageOutputRootPath === void 0 ? void 0 : imageOutputRootPath.length) > 0
+            ? imageOutputRootPath
+            : imageSet.pathToParentDocument, imageSet.outputFileName);
+        if (imageOutputRootPath && imageSet.localizedUrls.length) {
+            (0, log_1.error)("imageOutputPath was declared, but one or more localizedUrls were found too. If you are going to localize screenshots, then you can't declare an imageOutputPath.");
+            (0, process_1.exit)(1);
+        }
+        imageSet.filePathToUseInMarkdown =
+            ((imagePrefix === null || imagePrefix === void 0 ? void 0 : imagePrefix.length) > 0 ? imagePrefix : ".") +
+                "/" +
+                imageSet.outputFileName;
+    }
+    else {
+        (0, log_1.error)(`Something wrong with the filetype extension on the blob we got from ${imageSet.primaryUrl}`);
+        (0, process_1.exit)(1);
+    }
+}
+exports.makeImagePersistencePlan = makeImagePersistencePlan;
+function hashOfString(s) {
+    let hash = 0;
+    for (let i = 0; i < s.length; ++i)
+        hash = Math.imul(31, hash) + s.charCodeAt(i);
+    return Math.abs(hash);
+}

package/dist/NotionImage-CaptionReading.spec.d.ts

@@ -0,0 +1 @@
+export {};