semantifold 0.1.0

package/build/src/semantic/scalars.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Returns the canonical semantic scalar type reference.
+ * @param {import("./types.js").SemanticTypeName} name - Semantic scalar name.
+ * @returns {import("./types.js").TypeReference} Scalar type reference.
+ */
+export declare function scalarType(name: import("./types.js").SemanticTypeName): import("./types.js").TypeReference;
+/**
+ * Checks an opaque scalar type name without coercion.
+ * @param {string} name - Candidate semantic type name.
+ * @returns {name is import("./types.js").SemanticTypeName} Whether the name is supported.
+ */
+export declare function isScalarTypeName(name: string): name is import("./types.js").SemanticTypeName;
+/**
+ * Checks that a JavaScript string contains only complete Unicode scalar values.
+ * @param {string} value - Candidate Unicode string.
+ * @returns {boolean} Whether the string excludes lone UTF-16 surrogates.
+ */
+export declare function hasOnlyUnicodeScalars(value: string): boolean;
+//# sourceMappingURL=scalars.d.ts.map

package/build/src/semantic/scalars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../../../src/semantic/scalars.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAHpB,OAAO,YAAY,EAAE,gBAGD,GAFlB,OAAO,YAAY,EAAE,aAAa,CAI9C;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAH1B,MAG0B,GAFxB,IAAI,IAAI,OAAO,YAAY,EAAE,gBAAgB,CAIzD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAHhC,MAGgC,GAF9B,OAAO,CAiBnB"}

package/build/src/semantic/scalars.js

@@ -0,0 +1,40 @@
+// @ts-check
+/** @type {readonly import("./types.js").SemanticTypeName[]} */
+const scalarTypeNames = Object.freeze(["integer", "boolean", "string"]);
+/**
+ * Returns the canonical semantic scalar type reference.
+ * @param {import("./types.js").SemanticTypeName} name - Semantic scalar name.
+ * @returns {import("./types.js").TypeReference} Scalar type reference.
+ */
+export function scalarType(name) {
+    return { kind: /** @type {const} */ ("TypeReference"), name };
+}
+/**
+ * Checks an opaque scalar type name without coercion.
+ * @param {string} name - Candidate semantic type name.
+ * @returns {name is import("./types.js").SemanticTypeName} Whether the name is supported.
+ */
+export function isScalarTypeName(name) {
+    return scalarTypeNames.some((candidate) => candidate == name);
+}
+/**
+ * Checks that a JavaScript string contains only complete Unicode scalar values.
+ * @param {string} value - Candidate Unicode string.
+ * @returns {boolean} Whether the string excludes lone UTF-16 surrogates.
+ */
+export function hasOnlyUnicodeScalars(value) {
+    for (let index = 0; index < value.length; index++) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit >= 0xD800 && codeUnit <= 0xDBFF) {
+            const trailing = value.charCodeAt(index + 1);
+            if (!Number.isInteger(trailing) || trailing < 0xDC00 || trailing > 0xDFFF)
+                return false;
+            index++;
+        }
+        else if (codeUnit >= 0xDC00 && codeUnit <= 0xDFFF) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,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