@temperlang/core 0.4.0 → 0.5.0

package/core.js

@@ -98,6 +98,13 @@ export const bubble = () => {
   throw Error();
 };
 
+/**
+ * TODO Distinguish panic from bubble.
+ *
+ * @returns {never}
+ */
+export const panic = bubble;
+
 /**
  * @template T
  * @param {T} a
@@ -105,3 +112,75 @@ export const bubble = () => {
 export const print = (a) => {
   console.log("%s", a);
 };
+
+/**
+ * Takes a JSON adapter and a value that it can adapt.
+ * This is called when JavaScript code calls JSON.stringify on a Temper type instance
+ * that has a zero argument jsonAdapter static method.
+ *
+ * @return any
+ */
+export let marshalToJsonObject = (jsonAdapter, value) => {
+  let stack = [[]];
+  let pendingKey = null;
+  function store(value) {
+    let top = stack[stack.length - 1];
+    if (pendingKey !== null) {
+      top[pendingKey] = value;
+      pendingKey = null;
+    } else if (Array.isArray(top)) {
+      top.push(value);
+    } else {
+      throw new Error();
+    }
+  }
+  let jsonProducer = {
+    interchangeContext: { getHeader() { return null; } },
+
+    startObject() {
+      let o = {};
+      store(o);
+      stack.push(o);
+    },
+    endObject() { stack.pop(); },
+    objectKey(key) { pendingKey = String(key); },
+
+    startArray() {
+      let a = [];
+      store(a);
+      stack.push(a);
+    },
+    endArray() { stack.pop(); },
+
+    nullValue() { store(null); },
+    booleanValue(b) { store(!!b); },
+    intValue(v) { store(Math.trunc(v)); },
+    float64Value(v) { store(+v); },
+    numericTokenValue(s) { store(+s); },
+    stringValue(s) { store(`${s}`); },
+
+    parseErrorReceiver: null,
+  }
+  jsonAdapter.encodeToJson(value, jsonProducer);
+  return stack[0][0];
+};
+
+/** @type {{}} */
+let emptySingleton = Object.freeze(
+  // Prototype for empty
+  Object.create(
+    Object.freeze(
+      Object.create(
+        null,
+        {
+          toString: {
+            value: function toString() { return "(empty)" }
+          }
+        }
+      )
+    )
+  )
+);
+
+/** @return {{}} */
+export function empty() { return emptySingleton }

package/index.js

@@ -8,6 +8,7 @@ export * from "./float.js";
 export * from "./interface.js";
 export * from "./listed.js";
 export * from "./mapped.js";
+export * from "./net.js";
 export * from "./pair.js";
 export * from "./regex.js";
 export * from "./string.js";

package/interface.js

@@ -37,7 +37,7 @@ export const type = (...superTypes) => {
 
   class Union {
     static [Symbol.hasInstance] = (instance) => {
-      return key in instance;
+      return typeof instance === 'object' && instance !== null && key in instance;
     };
   }
 

package/mapped.js

@@ -156,7 +156,7 @@ export const mappedHas = (map, key) => {
  * @returns {Readonly<K[]>}
  */
 export const mappedKeys = (map) => {
-  return Object.freeze(Array.prototype.slice.call(map.keys()));
+  return Object.freeze(Array.from(map.keys()));
 }
 
 /**
@@ -165,7 +165,7 @@ export const mappedKeys = (map) => {
  * @returns {Readonly<V[]>}
  */
 export const mappedValues = (map) => {
-  return Object.freeze(Array.prototype.slice.call(map.values()));
+  return Object.freeze(Array.from(map.values()));
 }
 
 /**

package/net.js

@@ -0,0 +1,41 @@
+/**
+ * @param {string} url
+ * @param {"GET" | "POST"} method
+ * @param {string | null} bodyContent
+ * @param {string | null} bodyMimeType
+ * @return {Promise<Response>}
+ */
+export function stdNetSend(url, method, bodyContent, bodyMimeType) {
+  let details = { method };
+  if (typeof bodyContent === 'string') {
+    details.body = bodyContent;
+    if (typeof bodyMimeType === 'string') {
+      details.headers = { 'Content-Type': bodyMimeType };
+    }
+  }
+  return fetch(url, details);
+}
+
+/**
+ * @param {Response} r
+ * @return {number} an HTTP status code
+ */
+export function netResponseGetStatus(r) {
+  return r.status;
+}
+
+/**
+ * @param {Response} r
+ * @return {string | null} the mime-type of the body.
+ */
+export function netResponseGetContentType(r) {
+  return r.headers.get('Content-Type') || null;
+}
+
+/**
+ * @param {Response} r
+ * @return {Promise<string | null>} the body content.
+ */
+export function netResponseGetBodyContent(r) {
+  return r.text();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temperlang/core",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Runtime support for JS generated by Temper",
   "main": "index.js",
   "type": "module",

package/regex.js

@@ -108,7 +108,7 @@ export const regexCompiledSplit = (_, compiled, text) => {
 };
 
 /**
- * @param {RegExp} _
+ * @param {unknown} _
  * @param {string} formatted
  * @returns {RegExp}
  */
@@ -139,10 +139,16 @@ export const regexFormatterAdjustCodeSet = (self, codeSet, regexRefs) => {
   return codeSet;
 };
 
+/**
+ * @param {unknown} _
+ * @param {[string]} out
+ * @param {number} code
+ * @param {boolean} insideCodeSet
+ */
 export const regexFormatterPushCodeTo = (_, out, code, insideCodeSet) => {
   // Ignore insideCodeSet for now.
   // TODO(tjp, regex): Get fancier, including with work in Temper.
-  out.push(`\\u{${code.toString(16)}}`);
+  out[0] += `\\u{${code.toString(16)}}`;
 };
 
 // Cached later for some approximate efficiency.

package/string.js

@@ -1,12 +1,25 @@
 import { requireIsSafeInteger } from "./check-type.js";
 import {bubble} from "./core.js";
 
+/**
+ * Implements extension method String::fromCodePoint
+ * @param {number} codePoint
+ * @returns {string}
+ */
+export const stringFromCodePoint = (codePoint) => {
+    denySurrogate(codePoint);
+    return String.fromCodePoint(codePoint);
+};
+
 /**
  * Implements extension method String::fromCodePoints
  * @param {number[]} codePoints
  * @returns {string}
  */
 export const stringFromCodePoints = (codePoints) => {
+    for (const codePoint of codePoints) {
+        denySurrogate(codePoint);
+    }
     // TODO Append in batches if codePoints is long?
     return String.fromCodePoint(...codePoints);
 };
@@ -194,5 +207,15 @@ export const requireNoStringIndex = (i) => {
  * @param {number} c
  */
 export const stringBuilderAppendCodePoint = (s, c) => {
+    denySurrogate(c);
     s[0] += String.fromCodePoint(c);
 }
+
+/**
+ * @param {number} c
+ */
+const denySurrogate = (c) => {
+    if (c >= 0xD800 && c <= 0xDFFF) {
+        throw new RangeError(`Invalid Unicode scalar value ${c}`)
+    }
+}