@defold-typescript/types 0.54.0 → 0.56.0

package/dist/cli-runtime.js

@@ -1888,6 +1888,15 @@ function mapLualsExpression(token, resolveLeaf, position = "output") {
 function isLualsFunctionToken(token) {
   return /^fun\s*\(/.test(token.trim());
 }
+function mapLualsCallSignatureExpression(token, resolveLeaf, position = "output") {
+  const trimmed = token.trim();
+  if (!isLualsFunctionToken(trimmed)) {
+    throw new Error(`mapLualsCallSignature: expected a "fun(...)" token, got "${token}".`);
+  }
+  const walk = { resolveLeaf, unknowns: [], position };
+  const { paramList, ret } = functionParts(trimmed, walk);
+  return { ts: `(${paramList}): ${ret}`, unknowns: walk.unknowns };
+}
 var LUALS_THROWAWAY_PARAM = "_", LUALS_VARARG_TOKEN = "...", NUMERIC_LITERAL, TUPLE_KEY, INDEX_KEY;
 var init_luals_type_expr = __esm(() => {
   NUMERIC_LITERAL = /^-?\d+(\.\d+)?$/;
@@ -1954,6 +1963,15 @@ function weldStrandedListMarkers(text) {
   return out.join(`
 `).trim();
 }
+function stripMarkup(html) {
+  let text = html;
+  let previous;
+  do {
+    previous = text;
+    text = text.replace(MARKUP_TAG, "");
+  } while (text !== previous);
+  return text;
+}
 function preToMarkdown(inner) {
   const lines = htmlToCodeText(inner).split(`
 `);
@@ -1990,8 +2008,8 @@ ${LIST_INDENT.repeat(Math.max(0, listDepth - 1))}- `;
   }).replace(/<br\s*\/?>/gi, `
 `).replace(/<\/p>/gi, `
 
-`).replace(/<[^>]+>/g, "");
-  text = decodeEntities(text);
+`);
+  text = decodeEntities(stripMarkup(text));
   text = text.replace(/[ \t]+/g, " ").replace(/ *\n */g, `
 `).replace(/\n{3,}/g, `
 
@@ -2003,9 +2021,9 @@ ${LIST_INDENT.repeat(Math.max(0, listDepth - 1))}- `;
   return text.split("*/").join("*\\/");
 }
 function htmlToCodeText(html) {
-  let text = html.replace(/<br\s*\/?>/gi, `
-`).replace(/<[^>]+>/g, "");
-  text = decodeEntities(text);
+  const stripped = stripMarkup(html.replace(/<br\s*\/?>/gi, `
+`));
+  const text = decodeEntities(stripped);
   const lines = text.split(`
 `).map((line) => line.replace(/[ \t]+$/g, ""));
   while (lines.length > 0 && lines[0] === "")
@@ -2180,10 +2198,9 @@ function renderDocComment(parts) {
     }
     lines.push(" * ```");
   }
-  lines.push(" */");
-  return lines;
+  return [...lines.map((line) => line.replaceAll("*/", "*\\/")), " */"];
 }
-var NAMED_ENTITIES, LIST_INDENT = "", STRANDED_MARKER, LIST_ITEM, MISREAD_MARKDOWN_LINE, MANGLED_FENCE, FENCE_OPENER;
+var NAMED_ENTITIES, LIST_INDENT = "", STRANDED_MARKER, LIST_ITEM, MARKUP_TAG, MISREAD_MARKDOWN_LINE, MANGLED_FENCE, FENCE_OPENER;
 var init_doc_comment = __esm(() => {
   NAMED_ENTITIES = {
     amp: "&",
@@ -2212,6 +2229,12 @@ var init_doc_comment = __esm(() => {
   };
   STRANDED_MARKER = /^(*)-$/;
   LIST_ITEM = /^*- /;
+  MARKUP_TAG = new RegExp([
+    "</?(?:a|b|blockquote|br|code|dd|div|dl|dt|em|h[1-6]|hr|i|iframe|img|kbd|li|lia|ol|p|pre|s|script|small|span|strong|style|sub|sup|super|table|tbody|td|tfoot|th|thead|tr|u|ul)\\s*/?>",
+    "</?(?:script|style|iframe)\\b[^<>]*>",
+    `</?[a-z][^<>=]*=(?:[^<>"']|"[^"]*"|'[^']*')*>`,
+    "</?[a-z][^<>=]*=[^<>]*>"
+  ].join("|"), "gi");
   MISREAD_MARKDOWN_LINE = /^\s*`[^`]+`/;
   MANGLED_FENCE = /<code>([A-Za-z0-9_+-]+)\n([\s\S]*?)<\/code>/g;
   FENCE_OPENER = /^```([A-Za-z0-9_+-]+)$/;
@@ -2748,6 +2771,29 @@ ${sentence}`;
 function indexBaseNotes(elementName, kind, slotName) {
   return slotBaseNotes(INDEX_SLOT_CLASSIFICATIONS, "Defold", `${elementName}:${kind}:${slotName}`);
 }
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseLibraryIndexSlotClassifications(json) {
+  if (!isPlainObject(json)) {
+    throw new Error("library index-slot classifications must be a JSON object");
+  }
+  const map = new Map;
+  for (const [key, value] of Object.entries(json)) {
+    if (!isPlainObject(value)) {
+      throw new Error(`library index-slot classification ${key} must be an object`);
+    }
+    const { class: slotClass, evidence } = value;
+    if (typeof slotClass !== "string" || !INDEX_SLOT_CLASSES.has(slotClass)) {
+      throw new Error(`library index-slot classification ${key} has class ${JSON.stringify(slotClass)}, not one of ${[...INDEX_SLOT_CLASSES].join(", ")}`);
+    }
+    if (typeof evidence !== "string" || evidence.trim() === "") {
+      throw new Error(`library index-slot classification ${key} needs a non-blank evidence string`);
+    }
+    map.set(key, { class: slotClass, evidence });
+  }
+  return map;
+}
 function libraryIndexBaseNotes(classifications, page, elementName, kind, slotName) {
   return slotBaseNotes(classifications, `\`${page}\``, `${page}/${elementName}:${kind}:${slotName}`);
 }
@@ -4939,6 +4985,16 @@ function wholeTokenMapping(token) {
   }
   return recoverCallbackSignature(token) ?? undefined;
 }
+function unknownDefoldTypeLeaves(token) {
+  if (token === "nil" || wholeTokenMapping(token) !== undefined)
+    return [];
+  if (token.trim() === "")
+    return [token];
+  return mapLualsExpression(token, resolveDefoldLeaf).unknowns;
+}
+function isKnownDefoldTypeToken(token) {
+  return unknownDefoldTypeLeaves(token).length === 0;
+}
 function defaultMapType(token, position) {
   return wholeTokenMapping(token) ?? mapLualsExpression(token, resolveDefoldLeaf, position).ts;
 }
@@ -7829,7 +7885,10 @@ function readZipDirectory(bytes, path) {
     if (bytes.readUInt32LE(at) === ZIP_END_RECORD_SIGNATURE && at + ZIP_END_RECORD_SIZE + bytes.readUInt16LE(at + 20) === bytes.length) {
       const directory = readCentralDirectory(bytes, at, path);
       if (!(directory instanceof Error)) {
-        return directory;
+        return {
+          entries: directory,
+          comment: bytes.toString("utf8", at + ZIP_END_RECORD_SIZE, bytes.length)
+        };
       }
       nearestDefect ??= directory;
     }
@@ -7841,31 +7900,34 @@ function readZipDirectory(bytes, path) {
 }
 function readZip(path) {
   const bytes = readFileSync(path);
-  const entries = readZipDirectory(bytes, path);
+  const { entries, comment } = readZipDirectory(bytes, path);
+  const entryBytes = (name) => {
+    const entry = entries.get(name);
+    if (entry === undefined) {
+      throw new Error(`no entry ${name} in ${path}`);
+    }
+    const { localHeaderOffset, compressedSize, method } = entry;
+    if (bytes.readUInt32LE(localHeaderOffset) !== ZIP_LOCAL_HEADER_SIGNATURE) {
+      throw new Error(`${path}: local header of ${name} has no signature`);
+    }
+    const nameLength = bytes.readUInt16LE(localHeaderOffset + 26);
+    const extraLength = bytes.readUInt16LE(localHeaderOffset + 28);
+    const start = localHeaderOffset + 30 + nameLength + extraLength;
+    const data = bytes.subarray(start, start + compressedSize);
+    if (method === ZIP_METHOD_STORED) {
+      return data;
+    }
+    if (method === ZIP_METHOD_DEFLATE) {
+      return inflateRawSync(data);
+    }
+    throw new Error(`${path}: entry ${name} uses unsupported compression method ${method}`);
+  };
   return {
     has: (name) => entries.has(name),
     entries: () => [...entries.keys()],
-    read: (name) => {
-      const entry = entries.get(name);
-      if (entry === undefined) {
-        throw new Error(`no entry ${name} in ${path}`);
-      }
-      const { localHeaderOffset, compressedSize, method } = entry;
-      if (bytes.readUInt32LE(localHeaderOffset) !== ZIP_LOCAL_HEADER_SIGNATURE) {
-        throw new Error(`${path}: local header of ${name} has no signature`);
-      }
-      const nameLength = bytes.readUInt16LE(localHeaderOffset + 26);
-      const extraLength = bytes.readUInt16LE(localHeaderOffset + 28);
-      const start = localHeaderOffset + 30 + nameLength + extraLength;
-      const data = bytes.subarray(start, start + compressedSize);
-      if (method === ZIP_METHOD_STORED) {
-        return data.toString("utf8");
-      }
-      if (method === ZIP_METHOD_DEFLATE) {
-        return inflateRawSync(data).toString("utf8");
-      }
-      throw new Error(`${path}: entry ${name} uses unsupported compression method ${method}`);
-    }
+    read: (name) => entryBytes(name).toString("utf8"),
+    bytes: (name) => new Uint8Array(entryBytes(name)),
+    comment: () => comment
   };
 }
 function isRecord4(value) {