swipl-wasm 3.1.0 → 3.2.0

package/README.md

@@ -66,6 +66,26 @@ the `.js` file instead.
 </script>
 ```
 
+## Generating an image
+
+Often you will want to bundle a pre-built image of your prolog file. The easiest way to do this is using the `swipl-generate` command to generate the image. For example in `./examples/generation` the script: `swipl-generate ./max.pl ./dist/max.ts` will generate a file `./dist/max.ts` which contains the image of `./max.pl`. This file can then be imported into your project and used as follows:
+
+```ts
+import SWIPL from './max';
+
+async function main() {
+  const Module = await SWIPL();
+  const res = Module.prolog.query('max(1, 2, 3).');
+  console.log(res.next())
+}
+
+main();
+```
+
+Note that this procedure generates a file which imports directly from `swipl-wasm/dist/loadImageDefault`, so make sure that `swipl-wasm` is a direct dependency in your project rather than a dev dependency.
+
+To generate the image data without it pre-loaded into `SWIPL` use the `--image-only` flag.
+
 ## Running JavaScript from Prolog
 
 This uses `eval`:

package/dist/bin/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+const { generateLoadedImageFile, generateImageFile } = require('../generateImage')
+const path = require('path');
+
+function getPath(pth) {
+  return pth.startsWith('http://') || pth.startsWith('https://')
+    ? pth
+    : path.join(process.cwd(), pth)
+}
+
+async function mainFunc() {
+  let args = process.argv.slice(2);
+
+  const fn = process.argv.includes('--image-only') ? generateImageFile : generateLoadedImageFile;
+  args = args.filter(elem => elem !== '--image-only');
+
+  if (args.length !== 2) {
+    throw new Error('Expected exactly 2 inputs, input prolog (.pl) file and output file');
+  }
+
+  await fn(getPath(args[0]), getPath(args[1]));
+}
+
+mainFunc();

package/dist/generateImage.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+export declare function generateImageBuffer(prolog: string | Buffer): Promise<Uint8Array>;
+export declare function generateImageString(prolog: string | Buffer): Promise<string>;
+export declare function generateImageFileString(prolog: string | Buffer): Promise<string>;
+export declare function generateLoadedImageFileString(prolog: string | Buffer): Promise<string>;
+export declare function generateImageFile(prologPath: string, jsPath: string): Promise<void>;
+export declare function generateLoadedImageFile(prologPath: string, jsPath: string): Promise<void>;

package/dist/generateImage.js

@@ -0,0 +1,78 @@
+"use strict";
+/// <reference types="emscripten" />
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateLoadedImageFile = exports.generateImageFile = exports.generateLoadedImageFileString = exports.generateImageFileString = exports.generateImageString = exports.generateImageBuffer = void 0;
+const swipl_bundle_1 = __importDefault(require("./swipl/swipl-bundle"));
+const fs_1 = __importDefault(require("fs"));
+const cross_fetch_1 = require("cross-fetch");
+function Uint8ToString(u8a) {
+    const CHUNK_SZ = 0x8000;
+    const c = [];
+    for (let i = 0; i < u8a.length; i += CHUNK_SZ) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        c.push(String.fromCharCode.apply(null, u8a.subarray(i, i + CHUNK_SZ)));
+    }
+    return c.join('');
+}
+function generateImageBuffer(prolog) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const Module = yield (0, swipl_bundle_1.default)({
+            arguments: ['-q', '-f', 'prolog.pl'],
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            preRun: [(module) => { module.FS.writeFile('prolog.pl', prolog); }],
+        });
+        Module.prolog.query("qsave_program('prolog.pvm')").once();
+        return Module.FS.readFile('prolog.pvm');
+    });
+}
+exports.generateImageBuffer = generateImageBuffer;
+function generateImageString(prolog) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return btoa(Uint8ToString(yield generateImageBuffer(prolog)));
+    });
+}
+exports.generateImageString = generateImageString;
+function generateImageFileString(prolog) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return `export default "${yield generateImageString(prolog)}"\n`;
+    });
+}
+exports.generateImageFileString = generateImageFileString;
+function generateLoadedImageFileString(prolog) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return 'import loadImage from "swipl-wasm/dist/loadImageDefault"\n' +
+            'import strToBuffer from "swipl-wasm/dist/strToBuffer"\n\n' +
+            `export default loadImage(strToBuffer("${yield generateImageString(prolog)}"))\n`;
+    });
+}
+exports.generateLoadedImageFileString = generateLoadedImageFileString;
+function dereference(prologPath) {
+    return (prologPath.startsWith('http://') || prologPath.startsWith('https://'))
+        ? (0, cross_fetch_1.fetch)(prologPath).then((res) => res.text())
+        : fs_1.default.readFileSync(prologPath);
+}
+function generateImageFile(prologPath, jsPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        fs_1.default.writeFileSync(jsPath, yield generateImageFileString(yield dereference(prologPath)));
+    });
+}
+exports.generateImageFile = generateImageFile;
+function generateLoadedImageFile(prologPath, jsPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        fs_1.default.writeFileSync(jsPath, yield generateLoadedImageFileString(yield dereference(prologPath)));
+    });
+}
+exports.generateLoadedImageFile = generateLoadedImageFile;

package/dist/loadImage.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+/// <reference types="emscripten" />
+import type SWIPL_TYPE from './common';
+export declare function loadImage(image: string | Buffer | Uint8Array, swipl: typeof SWIPL_TYPE): (options?: Partial<EmscriptenModule> | undefined) => Promise<SWIPL_TYPE.SWIPLModule>;

package/dist/loadImage.js

@@ -0,0 +1,11 @@
+"use strict";
+/// <reference types="emscripten" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadImage = void 0;
+function loadImage(image, swipl) {
+    return (options) => swipl(Object.assign(Object.assign({}, options), { arguments: ['-q', '-x', 'image.pvm'], 
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        preRun: [(module) => module.FS.writeFile('image.pvm', image)] }));
+}
+exports.loadImage = loadImage;

package/dist/loadImageDefault.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+/// <reference types="emscripten" />
+import SWIPL from './swipl/swipl-bundle-no-data';
+export default function (image: string | Buffer | Uint8Array): (options?: Partial<EmscriptenModule> | undefined) => Promise<SWIPL.SWIPLModule>;

package/dist/loadImageDefault.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const swipl_bundle_no_data_1 = __importDefault(require("./swipl/swipl-bundle-no-data"));
+const loadImage_1 = require("./loadImage");
+function default_1(image) {
+    return (0, loadImage_1.loadImage)(image, swipl_bundle_no_data_1.default);
+}
+exports.default = default_1;

package/dist/strToBuffer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A function that converts a string into a buffer.
+ * This is required *only* for the conversion of the inlined
+ * EYE_PVM string into a buffer
+ * @param string The string to convert
+ * @returns A Uint8Array Buffer
+ */
+export default function strToBuffer(data: string): Uint8Array;

package/dist/strToBuffer.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-param-reassign,no-plusplus,no-bitwise,no-use-before-define,no-multi-assign */
+/* istanbul ignore file */
+/**
+ * A function that converts a string into a buffer.
+ * This is required *only* for the conversion of the inlined
+ * EYE_PVM string into a buffer
+ * @param string The string to convert
+ * @returns A Uint8Array Buffer
+ */
+function strToBuffer(data) {
+    if (data.length % 4 === 0) {
+        data = data.replace(/==?$/, '');
+    }
+    const output = [];
+    let buffer = 0;
+    let accumulatedBits = 0;
+    for (let i = 0; i < data.length; i++) {
+        buffer = (buffer << 6) | keystr.indexOf(data[i]);
+        accumulatedBits += 1;
+        if (accumulatedBits === 4) {
+            output.push((buffer & 0xff0000) >> 16, (buffer & 0xff00) >> 8, buffer & 0xff);
+            buffer = accumulatedBits = 0;
+        }
+    }
+    if (accumulatedBits === 2) {
+        output.push(buffer >> 4);
+    }
+    else if (accumulatedBits === 3) {
+        output.push(((buffer >>= 2) & 0xff00) >> 8, buffer & 0xff);
+    }
+    // "Return output."
+    return new Uint8Array(output);
+}
+exports.default = strToBuffer;
+/**
+ * A lookup table for atob(), which converts an ASCII character to the
+ * corresponding six-bit number.
+ */
+const keystr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

package/dist/swipl/swipl-bundle-no-data.d.ts

@@ -0,0 +1,2 @@
+import SWIPL = require("../common");
+export = SWIPL;