modality-ts 0.0.1 → 0.0.2

package/dist/extraction/index.d.ts

@@ -25,7 +25,7 @@ export interface UseStateExtractionResult {
 export interface ExtractedModelSkeleton extends UseStateExtractionResult {
     transitions: Transition[];
 }
-export declare function inferDomainFromTypeNode(node: ts.TypeNode | undefined): AbstractDomain;
+export declare function inferDomainFromTypeNode(node: ts.TypeNode | undefined, typeAliases?: ReadonlyMap<string, ts.TypeNode>): AbstractDomain;
 export declare function extractUseStateVars(sourceText: string, options?: UseStateExtractionOptions): UseStateExtractionResult;
 export declare function extractUseStateSkeleton(sourceText: string, options?: UseStateExtractionOptions): ExtractedModelSkeleton;
 //# sourceMappingURL=index.d.ts.map

package/dist/extraction/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extraction/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAA6B,YAAY,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACrH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAE/B,MAAM,WAAW,yBAAyB;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,KAAK,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IAClE,SAAS,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACpC,aAAa,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,sBAAuB,SAAQ,wBAAwB;IACtE,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AA0CD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,GAAG,SAAS,GAAG,cAAc,CAuBrF;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B,GAAG,wBAAwB,CAEzH;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B,GAAG,sBAAsB,CAyI3H"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extraction/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAA6B,YAAY,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACrH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAE/B,MAAM,WAAW,yBAAyB;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,KAAK,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IAClE,SAAS,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACpC,aAAa,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,sBAAuB,SAAQ,wBAAwB;IACtE,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AA0CD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,GAAG,SAAS,EAAE,WAAW,GAAE,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,QAAQ,CAAa,GAAG,cAAc,CAuBhJ;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B,GAAG,wBAAwB,CAEzH;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B,GAAG,sBAAsB,CA2I3H"}

package/dist/extraction/index.js

@@ -11,7 +11,7 @@ function setterBindingFromDecl(decl) {
         domain: decl.domain
     };
 }
-export function inferDomainFromTypeNode(node) {
+export function inferDomainFromTypeNode(node, typeAliases = new Map()) {
     if (!node)
         return { kind: "tokens", count: 1 };
     switch (node.kind) {
@@ -25,13 +25,13 @@ export function inferDomainFromTypeNode(node) {
         case ts.SyntaxKind.LiteralType:
             return domainFromLiteralType(node);
         case ts.SyntaxKind.UnionType:
-            return domainFromUnion(node);
+            return domainFromUnion(node, typeAliases);
         case ts.SyntaxKind.TypeLiteral:
             return domainFromTypeLiteral(node);
         case ts.SyntaxKind.ArrayType:
             return { kind: "lengthCat" };
         case ts.SyntaxKind.TypeReference:
-            return domainFromTypeReference(node);
+            return domainFromTypeReference(node, typeAliases);
         default:
             return { kind: "tokens", count: 1 };
     }
@@ -42,6 +42,7 @@ export function extractUseStateVars(sourceText, options = {}) {
 export function extractUseStateSkeleton(sourceText, options = {}) {
     const fileName = options.fileName ?? "App.tsx";
     const source = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    const typeAliases = typeAliasDeclarations(source);
     const vars = options.stateVars ? [...options.stateVars] : [];
     const transitions = [];
     const warnings = [];
@@ -96,7 +97,7 @@ export function extractUseStateSkeleton(sourceText, options = {}) {
             const stateName = node.name.elements[0];
             const setterName = node.name.elements[1];
             if (ts.isBindingElement(stateName) && ts.isIdentifier(stateName.name)) {
-                const domain = inferUseStateDomain(node.initializer);
+                const domain = inferUseStateDomain(node.initializer, typeAliases);
                 const component = nextComponent ?? "Anonymous";
                 const varId = `local:${component}.${stateName.name.text}`;
                 if (!options.stateVars) {
@@ -159,9 +160,10 @@ export function extractUseStateSkeleton(sourceText, options = {}) {
                 ts.forEachChild(node, (child) => visit(child, nextComponent));
                 return;
             }
+            const guardLocals = componentGuardLocalsFor(node, setters);
             const guard = combineParsedGuards([
-                renderGuardFor(node, setters, warnings, source, nextComponent ?? "Anonymous"),
-                disabledGuardFor(node, setters, warnings, source, nextComponent ?? "Anonymous")
+                renderGuardFor(node, setters, warnings, source, nextComponent ?? "Anonymous", guardLocals),
+                disabledGuardFor(node, setters, warnings, source, nextComponent ?? "Anonymous", guardLocals)
             ]);
             const extracted = transitionsFromJsxAttribute(source, fileName, node, setters, handlers, nextComponent ?? "Anonymous", effectApis, options.asyncOutcomes ?? {}, guard, warnings);
             transitions.push(...extracted);
@@ -223,10 +225,10 @@ function shortHash(value) {
     }
     return (hash >>> 0).toString(36).padStart(6, "0").slice(0, 6);
 }
-function inferUseStateDomain(call) {
+function inferUseStateDomain(call, typeAliases = new Map()) {
     const typeArg = call.typeArguments?.[0];
     if (typeArg)
-        return inferDomainFromTypeNode(typeArg);
+        return inferDomainFromTypeNode(typeArg, typeAliases);
     const initial = call.arguments[0];
     if (!initial)
         return { kind: "tokens", count: 1 };
@@ -289,10 +291,10 @@ function domainFromLiteralType(node) {
         return { kind: "option", inner: { kind: "tokens", count: 1 } };
     return { kind: "tokens", count: 1 };
 }
-function domainFromUnion(node) {
+function domainFromUnion(node, typeAliases = new Map()) {
     const nonNull = node.types.filter((part) => part.kind !== ts.SyntaxKind.UndefinedKeyword && !(ts.isLiteralTypeNode(part) && part.literal.kind === ts.SyntaxKind.NullKeyword));
     if (nonNull.length !== node.types.length && nonNull.length > 0) {
-        return { kind: "option", inner: nonNull.length === 1 ? inferDomainFromTypeNode(nonNull[0]) : domainFromUnionMembers(nonNull) };
+        return { kind: "option", inner: nonNull.length === 1 ? inferDomainFromTypeNode(nonNull[0], typeAliases) : domainFromUnionMembers(nonNull) };
     }
     return domainFromUnionMembers(node.types);
 }
@@ -353,14 +355,27 @@ function domainFromTypeLiteral(node, omitField) {
     }
     return { kind: "record", fields };
 }
-function domainFromTypeReference(node) {
+function domainFromTypeReference(node, typeAliases = new Map()) {
     const name = node.typeName.getText();
+    const alias = typeAliases.get(name);
+    if (alias)
+        return inferDomainFromTypeNode(alias, typeAliases);
     if ((name === "Array" || name === "ReadonlyArray") && node.typeArguments?.length === 1)
         return { kind: "lengthCat" };
     if (name === "Record")
         return { kind: "tokens", count: 1 };
     return { kind: "tokens", count: 1 };
 }
+function typeAliasDeclarations(source) {
+    const aliases = new Map();
+    const visit = (node) => {
+        if (ts.isTypeAliasDeclaration(node) && ts.isIdentifier(node.name))
+            aliases.set(node.name.text, node.type);
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return aliases;
+}
 function isUseStateCall(node) {
     return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "useState";
 }
@@ -504,9 +519,10 @@ function transitionsFromComponentPropAttribute(source, fileName, node, setters,
     const handler = handlerExpression(expression, handlers);
     if (!handler)
         return [];
+    const guardLocals = componentGuardLocalsFor(node, setters);
     const callerGuard = combineParsedGuards([
-        renderGuardFor(node, setters, warnings, source, component),
-        disabledGuardFor(node, setters, warnings, source, component)
+        renderGuardFor(node, setters, warnings, source, component, guardLocals),
+        disabledGuardFor(node, setters, warnings, source, component, guardLocals)
     ]);
     return tagStableIdKey(transitionsFromResolvedHandler(source, fileName, node, trigger.attr, handler, setters, handlers, component, effectApis, asyncOutcomes, combineParsedGuards([trigger.guard, callerGuard]), trigger.locator, warnings), handler);
 }
@@ -936,6 +952,30 @@ function effectWriteVars(effect) {
 function stateNameForVar(varId, setters) {
     return [...setters.values()].find((setter) => setter.varId === varId)?.stateName;
 }
+function componentGuardLocalsFor(attribute, setters) {
+    const body = enclosingFunctionBody(attribute);
+    if (!body)
+        return new Map();
+    const locals = new Map();
+    for (const statement of body.statements) {
+        if (statement.pos > attribute.pos)
+            break;
+        if (ts.isReturnStatement(statement))
+            break;
+        bindConstStatement(statement, setters, locals, true);
+    }
+    return locals;
+}
+function enclosingFunctionBody(node) {
+    let current = node;
+    while (current) {
+        if ((ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current)) && current.body && ts.isBlock(current.body)) {
+            return current.body;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
 function callSummaryFromHandler(handler, setters, initialLocals = new Map()) {
     const body = handler.body;
     if (ts.isCallExpression(body))
@@ -953,7 +993,7 @@ function callSummaryFromHandler(handler, setters, initialLocals = new Map()) {
     }
     return undefined;
 }
-function bindConstStatement(statement, setters, locals) {
+function bindConstStatement(statement, setters, locals, partialBoolean = false) {
     if (!ts.isVariableStatement(statement))
         return false;
     if ((ts.getCombinedNodeFlags(statement.declarationList) & ts.NodeFlags.Const) === 0)
@@ -961,7 +1001,8 @@ function bindConstStatement(statement, setters, locals) {
     for (const declaration of statement.declarationList.declarations) {
         if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
             return false;
-        const binding = valueExpr(declaration.initializer, setters, locals);
+        const binding = valueExpr(declaration.initializer, setters, locals) ??
+            (partialBoolean ? parseConjunctiveGuardExpression(declaration.initializer, setters, locals) : booleanExpr(declaration.initializer, setters, locals));
         if (!binding)
             return false;
         locals.set(declaration.name.text, binding);
@@ -1847,7 +1888,7 @@ function combineParsedGuards(guards) {
         reads: [...new Set(parsed.flatMap((guard) => guard.reads))]
     };
 }
-function renderGuardFor(eventAttribute, setters, warnings, source, component) {
+function renderGuardFor(eventAttribute, setters, warnings, source, component, locals = new Map()) {
     const element = jsxElementForAttribute(eventAttribute);
     if (!element)
         return undefined;
@@ -1857,7 +1898,7 @@ function renderGuardFor(eventAttribute, setters, warnings, source, component) {
         if (ts.isBinaryExpression(parent) &&
             parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken &&
             parent.right === current) {
-            const parsed = parseGuardExpression(parent.left, setters);
+            const parsed = parseConjunctiveGuardExpression(parent.left, setters, locals);
             if (!parsed) {
                 warnings.push({ message: `Unsupported render guard ${component}.${eventAttribute.name.getText(source)}`, ...lineAndColumn(source, parent.left) });
                 return undefined;
@@ -1865,7 +1906,7 @@ function renderGuardFor(eventAttribute, setters, warnings, source, component) {
             return parsed;
         }
         if (ts.isConditionalExpression(parent) && parent.whenTrue === current) {
-            const parsed = parseGuardExpression(parent.condition, setters);
+            const parsed = parseConjunctiveGuardExpression(parent.condition, setters, locals);
             if (!parsed) {
                 warnings.push({ message: `Unsupported render guard ${component}.${eventAttribute.name.getText(source)}`, ...lineAndColumn(source, parent.condition) });
                 return undefined;
@@ -1873,7 +1914,7 @@ function renderGuardFor(eventAttribute, setters, warnings, source, component) {
             return parsed;
         }
         if (ts.isConditionalExpression(parent) && parent.whenFalse === current) {
-            const parsed = parseGuardExpression(parent.condition, setters);
+            const parsed = parseConjunctiveGuardExpression(parent.condition, setters, locals);
             if (!parsed) {
                 warnings.push({ message: `Unsupported render guard ${component}.${eventAttribute.name.getText(source)}`, ...lineAndColumn(source, parent.condition) });
                 return undefined;
@@ -1897,50 +1938,73 @@ function jsxElementForAttribute(attribute) {
         return element.parent;
     return ts.isJsxSelfClosingElement(element) ? element : undefined;
 }
-function disabledGuardFor(eventAttribute, setters, warnings, source, component) {
+function disabledGuardFor(eventAttribute, setters, warnings, source, component, locals = new Map()) {
     const attrs = eventAttribute.parent;
     if (!ts.isJsxAttributes(attrs))
         return undefined;
-    const disabled = attrs.properties.find((property) => ts.isJsxAttribute(property) && ts.isIdentifier(property.name) && (property.name.text === "disabled" || property.name.text === "aria-disabled"));
+    const disabled = attrs.properties.find((property) => ts.isJsxAttribute(property) && ts.isIdentifier(property.name) && (property.name.text === "disabled" || property.name.text === "aria-disabled")) ?? submitButtonDisabledAttribute(eventAttribute);
     if (!disabled)
         return undefined;
-    const parsed = jsxAttributeBoolean(disabled, setters);
+    const parsed = jsxAttributeBoolean(disabled, setters, locals);
     if (!parsed) {
         warnings.push({ message: `Unsupported disabled guard ${component}.${eventAttribute.name.getText(source)}`, ...lineAndColumn(source, disabled) });
         return undefined;
     }
     return { expr: { kind: "not", args: [parsed.expr] }, reads: parsed.reads };
 }
-function jsxAttributeBoolean(attribute, setters) {
+function submitButtonDisabledAttribute(eventAttribute) {
+    if (!ts.isIdentifier(eventAttribute.name) || eventAttribute.name.text !== "onSubmit")
+        return undefined;
+    const element = jsxElementForAttribute(eventAttribute);
+    if (!element || !ts.isJsxElement(element))
+        return undefined;
+    let found;
+    const visit = (node) => {
+        if (found)
+            return;
+        if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+            const tag = ts.isIdentifier(node.tagName) ? node.tagName.text : undefined;
+            if (tag === "button" && stringAttribute(node.attributes, "type") === "submit") {
+                found = node.attributes.properties.find((property) => ts.isJsxAttribute(property) && ts.isIdentifier(property.name) && (property.name.text === "disabled" || property.name.text === "aria-disabled"));
+                if (found)
+                    return;
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(element);
+    return found;
+}
+function jsxAttributeBoolean(attribute, setters, locals = new Map()) {
     if (!attribute.initializer)
         return { expr: { kind: "lit", value: true }, reads: [] };
     if (ts.isStringLiteral(attribute.initializer))
         return { expr: { kind: "lit", value: attribute.initializer.text === "true" }, reads: [] };
     if (!ts.isJsxExpression(attribute.initializer) || !attribute.initializer.expression)
         return undefined;
-    return parseGuardExpression(attribute.initializer.expression, setters);
+    return parseConjunctiveGuardExpression(attribute.initializer.expression, setters, locals);
 }
-function parseGuardExpression(expression, setters) {
+function parseGuardExpression(expression, setters, locals = new Map()) {
     if (expression.kind === ts.SyntaxKind.TrueKeyword)
         return { expr: { kind: "lit", value: true }, reads: [] };
     if (expression.kind === ts.SyntaxKind.FalseKeyword)
         return { expr: { kind: "lit", value: false }, reads: [] };
     if (ts.isIdentifier(expression) || ts.isPropertyAccessExpression(expression))
-        return valueExpr(expression, setters, new Map());
+        return valueExpr(expression, setters, locals);
     if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.ExclamationToken) {
-        const parsed = parseGuardExpression(expression.operand, setters);
+        const parsed = parseGuardExpression(expression.operand, setters, locals);
         return parsed ? { expr: { kind: "not", args: [parsed.expr] }, reads: parsed.reads } : undefined;
     }
     if (ts.isParenthesizedExpression(expression))
-        return parseGuardExpression(expression.expression, setters);
+        return parseGuardExpression(expression.expression, setters, locals);
     if (ts.isBinaryExpression(expression))
-        return parseBinaryGuardExpression(expression, setters);
+        return parseBinaryGuardExpression(expression, setters, locals);
     return undefined;
 }
-function parseBinaryGuardExpression(expression, setters) {
+function parseBinaryGuardExpression(expression, setters, locals = new Map()) {
     if (expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || expression.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
-        const left = parseGuardExpression(expression.left, setters);
-        const right = parseGuardExpression(expression.right, setters);
+        const left = parseGuardExpression(expression.left, setters, locals);
+        const right = parseGuardExpression(expression.right, setters, locals);
         if (!left || !right)
             return undefined;
         return {
@@ -1952,8 +2016,8 @@ function parseBinaryGuardExpression(expression, setters) {
         expression.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken ||
         expression.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
         expression.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
-        const left = parseGuardOperand(expression.left, setters);
-        const right = parseGuardOperand(expression.right, setters);
+        const left = parseGuardOperand(expression.left, setters, locals);
+        const right = parseGuardOperand(expression.right, setters, locals);
         if (!left || !right)
             return undefined;
         return {
@@ -1966,13 +2030,24 @@ function parseBinaryGuardExpression(expression, setters) {
     }
     return undefined;
 }
-function parseGuardOperand(expression, setters) {
+function parseGuardOperand(expression, setters, locals = new Map()) {
     const value = literalValue(expression);
     if (value !== undefined)
         return { expr: { kind: "lit", value }, reads: [] };
     if (ts.isIdentifier(expression) || ts.isPropertyAccessExpression(expression))
-        return valueExpr(expression, setters, new Map());
-    return parseGuardExpression(expression, setters);
+        return valueExpr(expression, setters, locals);
+    return parseGuardExpression(expression, setters, locals);
+}
+function parseConjunctiveGuardExpression(expression, setters, locals = new Map()) {
+    if (ts.isParenthesizedExpression(expression))
+        return parseConjunctiveGuardExpression(expression.expression, setters, locals);
+    if (ts.isBinaryExpression(expression) && expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+        return combineParsedGuards([
+            parseConjunctiveGuardExpression(expression.left, setters, locals),
+            parseConjunctiveGuardExpression(expression.right, setters, locals)
+        ]);
+    }
+    return parseGuardExpression(expression, setters, locals);
 }
 function stateVarForName(name, setters) {
     return [...setters.values()].find((setter) => setter.stateName === name)?.varId;