moonflower 1.2.0 → 1.3.1

package/dist/openapi/analyzerModule/nodeParsers.mjs

@@ -1,279 +1,325 @@
 import { SyntaxKind as e } from "ts-morph";
-import { Logger as K } from "../../utils/logger.mjs";
-import { OpenApiManager as k } from "../manager/OpenApiManager.mjs";
-const S = /* @__PURE__ */ new WeakMap(), c = (t) => {
-  const r = S.get(t);
-  if (r)
-    return r;
+import { Logger as m } from "../../utils/logger.mjs";
+import { OpenApiManager as O } from "../manager/OpenApiManager.mjs";
+const L = /* @__PURE__ */ new WeakMap(), c = (t) => {
+  const n = L.get(t);
+  if (n)
+    return n;
   if (t.getKind() === e.Identifier) {
-    const i = t.asKind(e.Identifier).getImplementations()[0]?.getNode();
-    if (i) {
-      const o = i.getParent().getLastChild();
+    const r = t.asKind(e.Identifier).getImplementations()[0]?.getNode();
+    if (r) {
+      const o = r.getParent().getLastChild();
       if (o === t)
         throw new Error("Recursive implementation found");
-      const g = c(o);
-      return S.set(t, g), g;
+      const p = c(o);
+      return L.set(t, p), p;
     }
-    const f = t.asKind(e.Identifier).getDefinitions()[0]?.getNode();
-    if (f) {
-      const o = f.getParent().getLastChild();
+    const l = t.asKind(e.Identifier).getDefinitions()[0]?.getNode();
+    if (l) {
+      const o = l.getParent().getLastChild();
       if (o === t)
         throw new Error("Recursive implementation found");
-      const g = c(o);
-      return S.set(t, g), g;
+      const p = c(o);
+      return L.set(t, p), p;
     }
     throw new Error("No implementation nor definition available");
   }
-  return S.set(t, t), t;
-}, x = (t) => {
-  const r = t.getChildrenOfKind(e.Identifier);
-  return r.length === 2 ? c(r[1]) : t.getChildren().reverse().find(
-    (f) => f.getKind() !== e.GreaterThanToken && f.getKind() !== e.CommaToken && f.getKind() !== e.SemicolonToken
+  return L.set(t, t), t;
+}, C = (t) => {
+  const n = t.getChildrenOfKind(e.Identifier);
+  return n.length === 2 ? c(n[1]) : t.getChildren().reverse().find(
+    (l) => l.getKind() !== e.GreaterThanToken && l.getKind() !== e.CommaToken && l.getKind() !== e.SemicolonToken
   );
-}, w = (t) => {
-  const r = t.getFirstChildByKind(e.SyntaxList);
-  return r.isKind(e.SyntaxList) ? y(r.getFirstChild()) : y(r);
+}, P = (t) => {
+  const n = t.getFirstChildByKind(e.SyntaxList);
+  return n.isKind(e.SyntaxList) ? y(n.getFirstChild()) : y(n);
 }, y = (t) => {
-  const r = t.getSymbol()?.getName();
-  if (r && k.getInstance().hasExposedModel(r))
+  const n = t.getSymbol()?.getName();
+  if (n && O.getInstance().hasExposedModel(n))
     return [
       {
         role: "ref",
-        shape: r,
+        shape: n,
         optional: !1
       }
     ];
-  const i = c(t);
-  if (i.asKind(e.UndefinedKeyword))
+  const r = c(t);
+  if (r.asKind(e.UndefinedKeyword))
     return "undefined";
-  const n = i.asKind(e.LiteralType);
-  if (n) {
-    if (n.getFirstChildByKind(e.TrueKeyword))
+  const i = r.asKind(e.LiteralType);
+  if (i) {
+    if (i.getFirstChildByKind(e.TrueKeyword))
       return "true";
-    if (n.getFirstChildByKind(e.FalseKeyword))
+    if (i.getFirstChildByKind(e.FalseKeyword))
       return "false";
   }
-  if (i.asKind(e.BooleanKeyword) || i.asKind(e.TrueKeyword) || i.asKind(e.FalseKeyword))
+  if (r.asKind(e.BooleanKeyword) || r.asKind(e.TrueKeyword) || r.asKind(e.FalseKeyword))
     return "boolean";
-  if (i.asKind(e.StringKeyword) || i.asKind(e.StringLiteral))
+  if (r.asKind(e.StringKeyword) || r.asKind(e.StringLiteral))
     return "string";
-  if (i.asKind(e.NumberKeyword) || i.asKind(e.NumericLiteral))
+  if (r.asKind(e.NumberKeyword) || r.asKind(e.NumericLiteral))
     return "number";
-  if (i.asKind(e.BigIntKeyword) || i.asKind(e.BigIntLiteral))
+  if (r.asKind(e.BigIntKeyword) || r.asKind(e.BigIntLiteral))
     return "bigint";
-  const s = i.asKind(e.TypeLiteral);
+  const s = r.asKind(e.TypeLiteral);
   if (s)
-    return s.getFirstChildByKind(e.SyntaxList).getChildrenOfKind(e.PropertySignature).map((B) => {
-      const E = B.getFirstChildByKind(e.Identifier), I = x(B), D = E.getNextSiblingIfKind(e.QuestionToken);
+    return s.getFirstChildByKind(e.SyntaxList).getChildrenOfKind(e.PropertySignature).map((I) => {
+      const k = I.getFirstChildByKind(e.Identifier), v = C(I), R = k.getNextSiblingIfKind(e.QuestionToken);
       return {
         role: "property",
-        identifier: E.getText(),
-        shape: y(I),
-        optional: I.getType().isNullable() || !!D
+        identifier: k.getText(),
+        shape: y(v),
+        optional: v.getType().isNullable() || !!R
       };
     });
-  const d = i.asKind(e.TypeReference);
+  const d = r.asKind(e.TypeReference);
   if (d)
     return y(d.getFirstChild());
-  if (i.asKind(e.PropertyAccessExpression)) {
-    const P = c(i.getLastChild());
-    return u(P.asKind(e.CallExpression).getReturnType(), P);
+  if (r.asKind(e.PropertyAccessExpression)) {
+    const w = c(r.getLastChild());
+    return f(w.asKind(e.CallExpression).getReturnType(), w);
   }
-  const h = i.asKind(e.UnionType);
+  const h = r.asKind(e.UnionType);
   if (h)
-    return u(h.getType(), i);
-  const T = i.asKind(e.TypeQuery);
-  if (T)
-    return y(T.getLastChild());
-  const C = i.asKind(e.QualifiedName);
-  if (C)
-    return y(C.getLastChild());
-  const N = i.asKind(e.CallExpression);
-  if (N)
-    return u(N.getReturnType(), N);
-  const A = i.asKind(e.AwaitExpression);
-  if (A)
-    return y(A.getChildAtIndex(1));
-  const b = i.asKind(e.AsExpression);
-  if (b)
-    return y(b.getChildAtIndex(2));
-  const V = i.getSourceFile().getFilePath().split("/").pop();
-  return K.warn(`[${V}] Unknown node type: ${i.getKindName()}`), "unknown_1";
-}, j = (t) => t.getFirstDescendantByKind(e.SyntaxList).getChildrenOfKind(e.PropertyAssignment).map((n) => {
-  const o = n.getFirstChild(), g = (() => {
+    return f(h.getType(), r);
+  const S = r.asKind(e.TypeQuery);
+  if (S)
+    return y(S.getLastChild());
+  const F = r.asKind(e.QualifiedName);
+  if (F)
+    return y(F.getLastChild());
+  const x = r.asKind(e.CallExpression);
+  if (x)
+    return f(x.getReturnType(), x);
+  const B = r.asKind(e.AwaitExpression);
+  if (B)
+    return y(B.getChildAtIndex(1));
+  const E = r.asKind(e.AsExpression);
+  if (E)
+    return y(E.getChildAtIndex(2));
+  const D = r.getSourceFile().getFilePath().split("/").pop();
+  return m.warn(`[${D}] Unknown node type: ${r.getKindName()}`), "unknown_1";
+}, z = (t) => t.getFirstDescendantByKind(e.SyntaxList).getChildrenOfKind(e.PropertyAssignment).map((i) => {
+  const o = i.getFirstChild(), p = (() => {
     if (o.isKind(e.Identifier))
       return o.getText();
     if (o.isKind(e.StringLiteral))
       return o.getLiteralText();
-    const s = n.getSourceFile().getFilePath().split("/").pop();
-    return K.warn(`[${s}] Unknown identifier name: ${o.getText()}`), "unknown_30";
-  })(), a = n.getLastChild(), p = c(a);
+    const s = i.getSourceFile().getFilePath().split("/").pop();
+    return m.warn(`[${s}] Unknown identifier name: ${o.getText()}`), "unknown_30";
+  })(), a = i.getLastChild(), u = c(a);
   return {
     role: "property",
-    identifier: g,
-    shape: F(p),
-    optional: v(p),
-    description: m(p, "description"),
-    errorMessage: m(p, "errorMessage")
+    identifier: p,
+    shape: N(u),
+    optional: V(u),
+    description: K(u, "description"),
+    errorMessage: K(u, "errorMessage")
   };
-}) || [], F = (t) => {
-  const r = t.getParent().getFirstChildByKind(e.AsExpression);
-  if (r) {
-    const s = r.getLastChildByKind(e.TypeReference);
-    return w(s);
+}) || [], T = (t) => {
+  const n = t.asKind(e.CallExpression);
+  return n ? (n.getReturnType().getSymbol()?.getName() ?? "").startsWith("Zod") : !1;
+}, A = (t) => {
+  const n = t.asKind(e.CallExpression), l = n.getReturnType().getSymbol()?.getName() ?? "";
+  if (l === "ZodNumber")
+    return "number";
+  if (l === "ZodString")
+    return "string";
+  if (l === "ZodBoolean")
+    return "boolean";
+  if (l === "ZodBigInt")
+    return "bigint";
+  if (l === "ZodObject") {
+    const p = n.getFirstChildByKind(e.SyntaxList)?.getFirstChild()?.asKind(e.ObjectLiteralExpression);
+    if (!p)
+      return "unknown_zod_object";
+    const a = p.getFirstChildByKind(e.SyntaxList);
+    return a ? a.getChildrenOfKind(e.PropertyAssignment).map((s) => {
+      const d = s.getFirstChildByKind(e.Identifier).getText(), g = s.getLastChild();
+      return {
+        role: "property",
+        identifier: d,
+        shape: T(g) ? A(g) : N(g),
+        optional: !1
+      };
+    }) : [];
   }
-  const i = t.getParent().getFirstChildByKind(e.TypeReference);
-  if (i)
-    return w(i);
+  if (l === "ZodArray") {
+    const o = n.getFirstChildByKind(e.SyntaxList)?.getFirstChild();
+    return o ? [
+      {
+        role: "array",
+        shape: T(o) ? A(o) : N(o),
+        optional: !1
+      }
+    ] : "unknown_zod_array";
+  }
+  const i = t.getSourceFile().getFilePath().split("/").pop();
+  return m.warn(`[${i}] Unknown zod type: ${l}`), "unknown_zod";
+}, N = (t) => {
+  if (T(t))
+    return A(t);
+  const n = t.getParent().getFirstChildByKind(e.AsExpression);
+  if (n) {
+    const s = n.getLastChildByKind(e.TypeReference);
+    return P(s);
+  }
+  const r = t.getParent().getFirstChildByKind(e.TypeReference);
+  if (r)
+    return P(r);
   if (t.getParent().getChildrenOfKind(e.SyntaxList).length >= 2) {
     const s = t.getParent().getFirstChildByKind(e.SyntaxList).getFirstChild();
     return y(s);
   }
-  const f = t.getParent().getFirstChildByKind(e.CallExpression);
-  if (f) {
+  const l = t.getParent().getFirstChildByKind(e.CallExpression);
+  if (l) {
     const s = c(
-      f.getFirstChildByKind(e.SyntaxList).getFirstChild()
+      l.getFirstChildByKind(e.SyntaxList).getFirstChild()
     ), d = s.getParent().getFirstChildByKind(e.TypeReference);
     if (d)
-      return u(d.getType(), d, []);
-    const l = s.getParent().getFirstChildByKind(e.ObjectLiteralExpression);
-    if (l)
-      return F(l);
+      return f(d.getType(), d, []);
+    const g = s.getParent().getFirstChildByKind(e.ObjectLiteralExpression);
+    if (g)
+      return N(g);
     if (s.getKind() === e.CallExpression || s.getKind() === e.IntersectionType)
-      return F(s);
+      return N(s);
     const h = t.getSourceFile().getFilePath().split("/").pop();
-    return K.warn(`[${h}] Unknown call expression argument: ${s.getKindName()}`), "unknown_3";
+    return m.warn(`[${h}] Unknown call expression argument: ${s.getKindName()}`), "unknown_3";
   }
   const o = t.getFirstChildByKind(e.SyntaxList).getChildrenOfKind(e.PropertyAssignment).find((s) => s.getFirstChildByKind(e.Identifier)?.getText() === "parse");
   if (o) {
-    const s = x(o).asKind(e.ArrowFunction).getReturnType();
-    return u(s, o);
+    const s = C(o).asKind(e.ArrowFunction).getReturnType();
+    return f(s, o);
   }
-  const g = t.getFirstChildByKind(e.SyntaxList)?.getFirstChildByKind(e.ImportType);
-  if (g) {
-    const s = g.getLastChildByKind(e.GreaterThanToken).getChildIndex(), d = g.getChildAtIndex(s - 1);
+  const p = t.getFirstChildByKind(e.SyntaxList)?.getFirstChildByKind(e.ImportType);
+  if (p) {
+    const s = p.getLastChildByKind(e.GreaterThanToken).getChildIndex(), d = p.getChildAtIndex(s - 1);
     return y(d.getFirstChild());
   }
   const a = t.isKind(e.IntersectionType) ? t : t.getParent()?.isKind(e.VariableDeclaration) ? t.getParent()?.getFirstChildByKind(e.IntersectionType) : null;
   if (a) {
     const s = a.getFirstChildByKind(e.TypeReference);
     if (s)
-      return w(s);
+      return P(s);
   }
-  const p = t.getSourceFile().getFilePath().split("/").pop();
-  return K.warn(`[${p}] Unknown import type node`), "unknown_2";
-}, v = (t) => {
-  const r = t.asKind(e.CallExpression);
-  if (r) {
-    const n = r.getFirstChildByKind(e.Identifier);
-    if (n?.getText() === "OptionalParam")
+  const u = t.getSourceFile().getFilePath().split("/").pop();
+  return m.warn(`[${u}] Unknown import type node`), "unknown_2";
+}, V = (t) => {
+  if (T(t))
+    return !1;
+  const n = t.asKind(e.CallExpression);
+  if (n) {
+    const i = n.getFirstChildByKind(e.Identifier);
+    if (i?.getText() === "OptionalParam")
       return !0;
-    if (n?.getText() === "RequiredParam")
+    if (i?.getText() === "RequiredParam")
       return !1;
-    const o = r.getFirstChildByKind(e.SyntaxList), g = c(o.getFirstChild());
-    return v(g);
+    const o = n.getFirstChildByKind(e.SyntaxList), p = c(o.getFirstChild());
+    return V(p);
   }
-  return t.getFirstDescendantByKind(e.SyntaxList).getChildrenOfKind(e.PropertyAssignment).some((n) => n.getFirstDescendantByKind(e.Identifier).getText() === "optional" ? x(n).getKind() === e.TrueKeyword : !1);
-}, m = (t, r) => {
-  const i = c(t), f = i.asKind(e.CallExpression);
-  if (f) {
-    const d = f.getLastChildByKind(e.SyntaxList);
-    return m(d, r);
+  return t.getFirstDescendantByKind(e.SyntaxList).getChildrenOfKind(e.PropertyAssignment).some((i) => i.getFirstDescendantByKind(e.Identifier).getText() === "optional" ? C(i).getKind() === e.TrueKeyword : !1);
+}, K = (t, n) => {
+  if (T(t))
+    return "";
+  const r = c(t), l = r.asKind(e.CallExpression);
+  if (l) {
+    const d = l.getLastChildByKind(e.SyntaxList);
+    return K(d, n);
   }
-  const n = i.asKind(e.SyntaxList);
-  if (n)
-    return n.getChildren().map((l) => m(l, r)).find((l) => !!l && l !== "unknown_25") || "";
-  const o = i.asKind(e.ObjectLiteralExpression);
+  const i = r.asKind(e.SyntaxList);
+  if (i)
+    return i.getChildren().map((g) => K(g, n)).find((g) => !!g && g !== "unknown_25") || "";
+  const o = r.asKind(e.ObjectLiteralExpression);
   if (o) {
-    const l = O(o).find((h) => h.identifier === r);
-    return l ? Array.isArray(l.value) ? "array" : l.value || "" : "";
+    const g = _(o).find((h) => h.identifier === n);
+    return g ? Array.isArray(g.value) ? "array" : g.value || "" : "";
   }
-  const g = i.asKind(e.IntersectionType);
-  if (g)
-    return g.getTypeNodes().flatMap((d) => m(d, r)).filter((d) => !!d && d !== "unknown_25")[0] || "unknown_27";
-  const a = i.asKind(e.TypeLiteral);
+  const p = r.asKind(e.IntersectionType);
+  if (p)
+    return p.getTypeNodes().flatMap((d) => K(d, n)).filter((d) => !!d && d !== "unknown_25")[0] || "unknown_27";
+  const a = r.asKind(e.TypeLiteral);
   if (a)
-    return m(a.getFirstChildByKind(e.SyntaxList), r);
-  const p = i.asKind(e.PropertySignature);
-  if (p && i.getFirstDescendantByKind(e.Identifier).getText() === r)
-    return x(p).getFirstDescendantByKind(
+    return K(a.getFirstChildByKind(e.SyntaxList), n);
+  const u = r.asKind(e.PropertySignature);
+  if (u && r.getFirstDescendantByKind(e.Identifier).getText() === n)
+    return C(u).getFirstDescendantByKind(
       e.StringLiteral
     ).getLiteralText();
-  const s = i.getSourceFile().getFilePath().split("/").pop();
-  return K.dev(`[${s}] Unknown property string value node ${i.getKindName()}`), "unknown_25";
-}, R = (t) => {
-  const r = t.getSymbol();
-  if (!t.isObject() || !r)
+  const s = r.getSourceFile().getFilePath().split("/").pop();
+  return m.dev(`[${s}] Unknown property string value node ${r.getKindName()}`), "unknown_25";
+}, $ = (t) => {
+  const n = t.getSymbol();
+  if (!t.isObject() || !n)
     return !1;
-  const i = t.getTypeArguments();
-  return r.getName() === "Promise" && i.length === 1;
-}, u = (t, r, i = []) => {
-  const f = t.getAliasSymbol()?.getName();
-  if (f && k.getInstance().hasExposedModel(f))
+  const r = t.getTypeArguments();
+  return n.getName() === "Promise" && r.length === 1;
+}, f = (t, n, r = []) => {
+  const l = t.getAliasSymbol()?.getName();
+  if (l && O.getInstance().hasExposedModel(l))
     return [
       {
         role: "ref",
-        shape: f,
+        shape: l,
         optional: !1
       }
     ];
-  const n = R(t) ? t.getTypeArguments()[0] : t;
-  if (i.some((a) => a === n))
+  const i = $(t) ? t.getTypeArguments()[0] : t;
+  if (r.some((a) => a === i))
     return "circular";
-  const o = i.concat(n);
-  if (n.getText() === "void")
+  const o = r.concat(i);
+  if (i.getText() === "void")
     return "void";
-  if (n.isAny())
+  if (i.isAny())
     return "any";
-  if (n.isNull())
+  if (i.isNull())
     return "null";
-  if (n.isUndefined())
+  if (i.isUndefined())
     return "undefined";
-  if (n.isBoolean() || n.isBooleanLiteral())
+  if (i.isBoolean() || i.isBooleanLiteral())
     return "boolean";
-  if (n.isStringLiteral())
+  if (i.isStringLiteral())
     return [
       {
         role: "literal_string",
-        shape: String(n.getLiteralValue()),
+        shape: String(i.getLiteralValue()),
         optional: !1
       }
     ];
-  if (n.isNumberLiteral())
+  if (i.isNumberLiteral())
     return [
       {
         role: "literal_number",
-        shape: String(n.getLiteralValue()),
+        shape: String(i.getLiteralValue()),
         optional: !1
       }
     ];
-  if (n.isString() || n.isTemplateLiteral())
+  if (i.isString() || i.isTemplateLiteral())
     return "string";
-  if (n.isNumber())
+  if (i.isNumber())
     return "number";
-  if (n.getText() === "bigint")
+  if (i.getText() === "bigint")
     return "bigint";
-  if (n.isTuple())
+  if (i.isTuple())
     return [
       {
         role: "tuple",
-        shape: n.getTupleElements().map((a) => ({
+        shape: i.getTupleElements().map((a) => ({
           role: "tuple_entry",
-          shape: u(a, r, o),
+          shape: f(a, n, o),
           optional: !1
         })),
         optional: !1
       }
     ];
-  if (n.isArray())
+  if (i.isArray())
     return [
       {
         role: "array",
-        shape: u(n.getArrayElementType(), r, o),
+        shape: f(i.getArrayElementType(), n, o),
         optional: !1
       }
     ];
-  if (n.isObject() && n.getText() === "Buffer")
+  if (i.isObject() && i.getText() === "Buffer")
     return [
       {
         role: "buffer",
@@ -281,49 +327,50 @@ const S = /* @__PURE__ */ new WeakMap(), c = (t) => {
         optional: !1
       }
     ];
-  if (n.isObject() && n.getProperties().length === 0) {
-    const a = n.getAliasTypeArguments()[1];
-    return [
-      {
-        role: "record",
-        shape: u(a, r, o),
-        optional: !1
-      }
-    ];
+  if (i.isObject() && i.getProperties().length === 0) {
+    const a = i.getAliasTypeArguments()[1] ?? i.getStringIndexType();
+    if (a)
+      return [
+        {
+          role: "record",
+          shape: f(a, n, o),
+          optional: !1
+        }
+      ];
   }
-  if (n.isObject())
-    return n.getText() === "Date" ? "Date" : n.getProperties().map((a) => {
-      const p = a.getValueDeclaration() || a.getDeclarations()[0];
-      if (!p)
+  if (i.isObject())
+    return i.getText() === "Date" ? "Date" : i.getProperties().map((a) => {
+      const u = a.getValueDeclaration() || a.getDeclarations()[0];
+      if (!u)
         return {
           role: "property",
           identifier: a.getName(),
-          shape: u(a.getTypeAtLocation(r), r, o),
+          shape: f(a.getTypeAtLocation(n), n, o),
           optional: !1
         };
-      if (!(p.asKind(e.PropertySignature) || p.asKind(e.PropertyAssignment) || p.asKind(e.ShorthandPropertyAssignment)))
+      if (!(u.asKind(e.PropertySignature) || u.asKind(e.PropertyAssignment) || u.asKind(e.ShorthandPropertyAssignment)))
         return {
           role: "property",
           identifier: a.getName(),
-          shape: u(a.getTypeAtLocation(r), r, o),
+          shape: f(a.getTypeAtLocation(n), n, o),
           optional: !1
         };
-      const d = a.getTypeAtLocation(r).isNullable(), l = u(a.getTypeAtLocation(r), r, o);
+      const d = a.getTypeAtLocation(n).isNullable(), g = f(a.getTypeAtLocation(n), n, o);
       return {
         role: "property",
         identifier: a.getName(),
-        shape: l,
+        shape: g,
         optional: d
       };
     }).filter((a) => a.shape !== "undefined");
-  if (n.isUnion()) {
-    const p = n.getUnionTypes().map((l) => ({
+  if (i.isUnion()) {
+    const u = i.getUnionTypes().map((g) => ({
       role: "union_entry",
-      shape: u(l, r, o),
+      shape: f(g, n, o),
       optional: !1
     })).filter(
-      (l, h, T) => !T.find((C, N) => C.shape === l.shape && N > h)
-    ), s = p.some((l) => l.shape === "undefined"), d = p.filter((l) => l.shape !== "undefined");
+      (g, h, S) => !S.find((F, x) => F.shape === g.shape && x > h)
+    ), s = u.some((g) => g.shape === "undefined"), d = u.filter((g) => g.shape !== "undefined");
     return d.length === 1 ? d[0].shape : [
       {
         role: "union",
@@ -332,40 +379,48 @@ const S = /* @__PURE__ */ new WeakMap(), c = (t) => {
       }
     ];
   }
-  if (n.isIntersection())
-    return n.getIntersectionTypes().map((s) => u(s, r, o)).filter((s) => typeof s != "string").reduce((s, d) => [...s, ...d], []);
-  const g = r.getSourceFile().getFilePath().split("/").pop();
-  return K.warn(`[${g}] Unknown type shape node ${t.getText()}`), "unknown_5";
-}, L = (t) => {
+  if (i.isIntersection())
+    return i.getIntersectionTypes().map((s) => f(s, n, o)).filter((s) => typeof s != "string").reduce((s, d) => [...s, ...d], []);
+  const p = n.getSourceFile().getFilePath().split("/").pop();
+  return m.warn(`[${p}] Unknown type shape node ${t.getText()}`), "unknown_5";
+}, b = (t) => {
   if (t.isKind(e.Identifier))
-    return L(c(t));
+    return b(c(t));
   if (t.isKind(e.StringLiteral))
     return t.getLiteralValue();
   if (t.isKind(e.ArrayLiteralExpression))
-    return t.forEachChildAsArray().map((i) => L(i));
+    return t.forEachChildAsArray().map((r) => b(r));
   if (t.isKind(e.PropertyAccessExpression))
-    return L(x(t));
+    return b(C(t));
   if (t.isKind(e.ObjectLiteralExpression))
-    return O(t);
-  const r = t.getSourceFile().getFilePath().split("/").pop();
-  return K.dev(`[${r}] Unknown literal value node ${t.getKindName()}`), "unknown_6";
-}, O = (t) => t.getFirstDescendantByKind(e.SyntaxList).getChildrenOfKind(e.PropertyAssignment).map((n) => {
-  const g = n.getFirstDescendantByKind(e.Identifier).getText(), a = n.getLastChild(), p = c(a), s = L(p);
+    return _(t);
+  const n = t.getSourceFile().getFilePath().split("/").pop();
+  return m.dev(`[${n}] Unknown literal value node ${t.getKindName()}`), "unknown_6";
+}, Q = (t) => {
+  const n = t.getFirstDescendantByKind(e.CallExpression);
+  if (!n) return null;
+  const r = n.getArguments()[0];
+  if (!r) return null;
+  const l = r.getType();
+  return l.isStringLiteral() ? l.getLiteralValue() : null;
+}, _ = (t) => t.getFirstDescendantByKind(e.SyntaxList).getChildrenOfKind(e.PropertyAssignment).map((i) => {
+  const p = i.getFirstDescendantByKind(e.Identifier).getText(), a = i.getLastChild(), u = c(a), s = b(u);
   return {
-    identifier: g,
+    identifier: p,
     value: s
   };
 }) || [];
 export {
   c as findNodeImplementation,
-  x as findPropertyAssignmentValueNode,
-  u as getProperTypeShape,
+  C as findPropertyAssignmentValueNode,
+  f as getProperTypeShape,
   y as getRecursiveNodeShape,
-  j as getShapeOfValidatorLiteral,
-  w as getTypeReferenceShape,
-  v as getValidatorPropertyOptionality,
-  F as getValidatorPropertyShape,
-  m as getValidatorPropertyStringValue,
-  O as getValuesOfObjectLiteral
+  z as getShapeOfValidatorLiteral,
+  P as getTypeReferenceShape,
+  V as getValidatorPropertyOptionality,
+  N as getValidatorPropertyShape,
+  K as getValidatorPropertyStringValue,
+  _ as getValuesOfObjectLiteral,
+  Q as resolveEndpointPath
 };
 //# sourceMappingURL=nodeParsers.mjs.map