@intentius/tsad-conformance 1.4.0 → 1.6.0

package/fixtures/F-Val-Source/a-form-per-case-in-data-host/expect.json

@@ -0,0 +1,74 @@
+{
+  "rules": [
+    "F-Val-Source"
+  ],
+  "project": true,
+  "host": "shapes",
+  "profiles": [
+    "data-host"
+  ],
+  "verdicts": {
+    "app.ts": "fold"
+  },
+  "exports": {
+    "app.ts": {
+      "scalars": {
+        "s": "text",
+        "n": 1.5,
+        "b": true,
+        "z": null,
+        "u": "$undefined"
+      },
+      "nested": [
+        1,
+        {
+          "a-b": [
+            2,
+            3
+          ]
+        }
+      ],
+      "logs": {
+        "__resource": "Bucket",
+        "props": {
+          "name": "logs"
+        },
+        "attributes": {
+          "region": "eu"
+        }
+      },
+      "arn": {
+        "__attrRef": {
+          "entity": "logs",
+          "attribute": "arn"
+        }
+      },
+      "tagged": {
+        "__intrinsic": "join",
+        "strings": [
+          "arn:",
+          ":",
+          ""
+        ],
+        "values": [
+          {
+            "__symbol": "Region.Name"
+          },
+          {
+            "__attrRef": {
+              "entity": "logs",
+              "attribute": "arn"
+            }
+          }
+        ]
+      },
+      "called": {
+        "__intrinsic": "ref",
+        "args": [
+          "logs"
+        ]
+      }
+    }
+  },
+  "note": "F-Val-Source's table, written by hand: the form it names for each case that data-host has, scalar, array, object, resource, attribute reference, both intrinsic forms and a symbol inside an interior, and the value each folds to. The roundtrip family is the same table with the source written by the implementation's generator."
+}

package/fixtures/F-Val-Source/a-form-per-case-in-data-host/project/app.ts

@@ -0,0 +1,8 @@
+import { Bucket, join, ref } from "@tsad/shapes";
+
+export const scalars = { s: "text", n: 1.5, b: true, z: null, u: undefined };
+export const nested = [1, { "a-b": [2, 3] }];
+export const logs = new Bucket({ name: "logs" }, { region: "eu" });
+export const arn = logs.arn;
+export const tagged = join`arn:${Region.Name}:${logs.arn}`;
+export const called = ref("logs");

package/fixtures/F-Val-Source/a-form-per-case-in-full/expect.json

@@ -0,0 +1,35 @@
+{
+  "rules": [
+    "F-Val-Source",
+    "F-Val-Fate"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "app.ts": "fold"
+  },
+  "exports": {
+    "app.ts": {
+      "logs": {
+        "entityType": "Bucket",
+        "lexicon": "shapes",
+        "props": {
+          "name": "logs"
+        },
+        "attributes": {}
+      },
+      "arn": {
+        "__attrRef": {
+          "entity": "logs",
+          "attribute": "arn"
+        }
+      },
+      "tagged": "arn:logs",
+      "called": {
+        "Ref": "logs"
+      },
+      "helped": "LOGS"
+    }
+  },
+  "note": "The same forms in full, where the fold of a form is the value after F-Val-Fate: the resource is a live instance, the intrinsics and the helper are invoked, and only the attribute reference at the top is still the envelope. Inside the tag's interpolation an attribute reference would be rejected (F-Val-Position), so the span holds a literal. This is why the round trip is stated per profile."
+}

package/fixtures/F-Val-Source/a-form-per-case-in-full/project/app.ts

@@ -0,0 +1,7 @@
+import { Bucket, join, ref, upper } from "@tsad/shapes";
+
+export const logs = new Bucket({ name: "logs" });
+export const arn = logs.arn;
+export const tagged = join`arn:${"logs"}`;
+export const called = ref("logs");
+export const helped = upper("logs");

package/fixtures/F-Val-Symbol-Scope/a-symbol-only-inside-an-intrinsic/expect.json

@@ -0,0 +1,32 @@
+{
+  "rules": [
+    "F-Val-Symbol-Scope",
+    "F-Eval-Interior"
+  ],
+  "project": true,
+  "host": "shapes",
+  "profiles": [
+    "data-host"
+  ],
+  "verdicts": {
+    "interior.ts": "fold",
+    "top.ts": "run"
+  },
+  "exports": {
+    "interior.ts": {
+      "inside": {
+        "__intrinsic": "join",
+        "strings": [
+          "arn:",
+          ":logs"
+        ],
+        "values": [
+          {
+            "__symbol": "Region.Name"
+          }
+        ]
+      }
+    }
+  },
+  "note": "The same unresolved chain twice. Inside a tag's interpolation it folds to a __symbol envelope, which the intrinsic will resolve; at the top of an expression it is a located rejection and the file runs. A __symbol never appears at the top of a folded tree."
+}

package/fixtures/F-Val-Symbol-Scope/a-symbol-only-inside-an-intrinsic/project/interior.ts

@@ -0,0 +1,3 @@
+import { join } from "@tsad/shapes";
+
+export const inside = join`arn:${Region.Name}:logs`;

package/fixtures/F-Val-Symbol-Scope/a-symbol-only-inside-an-intrinsic/project/top.ts

@@ -0,0 +1 @@
+export const top = Region.Name;

package/fixtures/S-Disqualify/each-arm-disqualifies-the-file/expect.json

@@ -0,0 +1,34 @@
+{
+  "rules": [
+    "S-Disqualify",
+    "F-Scan"
+  ],
+  "project": true,
+  "verdicts": {
+    "ok.ts": "fold",
+    "let.ts": "run",
+    "var.ts": "run",
+    "class.ts": "run",
+    "star.ts": "run",
+    "uninitialized.ts": "run",
+    "array.ts": "run",
+    "rest.ts": "run",
+    "default-function.ts": "run"
+  },
+  "rejectRule": {
+    "let.ts": "F-Scan",
+    "var.ts": "F-Scan",
+    "class.ts": "F-Scan",
+    "star.ts": "F-Scan",
+    "uninitialized.ts": "F-Scan",
+    "array.ts": "F-Scan",
+    "rest.ts": "F-Scan",
+    "default-function.ts": "F-Scan"
+  },
+  "exports": {
+    "ok.ts": {
+      "fine": 1
+    }
+  },
+  "note": "One file per disqualifying statement form, and one that folds. A single match rejects the whole file at F-Scan before any expression is judged; export default with an expression is the arm S-ExportDefault admits in data-host, so it is not here."
+}

package/fixtures/S-Disqualify/each-arm-disqualifies-the-file/project/array.ts

@@ -0,0 +1 @@
+export const [x] = [1];

package/fixtures/S-Disqualify/each-arm-disqualifies-the-file/project/class.ts

@@ -0,0 +1 @@
+export class X {}

package/fixtures/S-Disqualify/each-arm-disqualifies-the-file/project/default-function.ts

@@ -0,0 +1,3 @@
+export default function x() {
+  return 1;
+}

package/fixtures/S-Disqualify/each-arm-disqualifies-the-file/project/let.ts

@@ -0,0 +1 @@
+export let x = 1;

package/fixtures/S-Disqualify/each-arm-disqualifies-the-file/project/ok.ts

@@ -0,0 +1 @@
+export const fine = 1;

package/fixtures/S-Disqualify/each-arm-disqualifies-the-file/project/rest.ts

@@ -0,0 +1 @@
+export const { ...rest } = { a: 1 };

package/fixtures/S-Disqualify/each-arm-disqualifies-the-file/project/star.ts

@@ -0,0 +1 @@
+export * from "./let";

package/fixtures/S-Disqualify/each-arm-disqualifies-the-file/project/uninitialized.ts

@@ -0,0 +1 @@
+export const x: number;

package/fixtures/S-Disqualify/each-arm-disqualifies-the-file/project/var.ts

@@ -0,0 +1 @@
+export var x = 1;

package/fixtures/S-ExportDestructure/plain-elements/expect.json

@@ -0,0 +1,16 @@
+{
+  "rules": [
+    "S-ExportDestructure"
+  ],
+  "project": true,
+  "verdicts": {
+    "app.ts": "fold"
+  },
+  "exports": {
+    "app.ts": {
+      "port": 8080,
+      "hostname": "localhost"
+    }
+  },
+  "note": "A destructured export with plain elements only, one of them renamed. Each element becomes an export bound to the property of the folded initializer; the property nobody named is not exported."
+}

package/fixtures/S-ExportDestructure/plain-elements/project/app.ts

@@ -0,0 +1,3 @@
+const config = { port: 8080, host: "localhost", debug: false };
+
+export const { port, host: hostname } = config;

package/fixtures/S-ExportNamed/local-names-with-an-alias/expect.json

@@ -0,0 +1,19 @@
+{
+  "rules": [
+    "S-ExportNamed",
+    "S-TopConst"
+  ],
+  "project": true,
+  "verdicts": {
+    "app.ts": "fold"
+  },
+  "exports": {
+    "app.ts": {
+      "a": 1,
+      "c": {
+        "two": 2
+      }
+    }
+  },
+  "note": "An export list over local names, one aliased. Each element exports the binding S-TopConst made under the name the list gives it."
+}

package/fixtures/S-ExportNamed/local-names-with-an-alias/project/app.ts

@@ -0,0 +1,4 @@
+const a = 1;
+const b = { two: 2 };
+
+export { a, b as c };

package/fixtures/S-ExportResource/new-with-props/expect.json

@@ -0,0 +1,26 @@
+{
+  "rules": [
+    "S-ExportResource",
+    "F-Val-Fate"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "app.ts": "fold"
+  },
+  "exports": {
+    "app.ts": {
+      "logs": {
+        "entityType": "Bucket",
+        "lexicon": "shapes",
+        "props": {
+          "BucketName": "logs"
+        },
+        "attributes": {
+          "region": "eu"
+        }
+      }
+    }
+  },
+  "note": "The resource declarator: export const, an identifier, a new expression with arguments. J1 yields a __resource envelope and revival constructs the class the file imported from props and attributes."
+}

package/fixtures/S-ExportResource/new-with-props/project/app.ts

@@ -0,0 +1,3 @@
+import { Bucket } from "@tsad/shapes";
+
+export const logs = new Bucket({ BucketName: "logs" }, { region: "eu" });

package/fixtures/S-ExportSingle/an-expression-initializer/expect.json

@@ -0,0 +1,21 @@
+{
+  "rules": [
+    "S-ExportSingle",
+    "S-Object"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "fold",
+  "value": {
+    "a": 1,
+    "b": [
+      true,
+      null,
+      "s"
+    ],
+    "c": {
+      "d": 2
+    }
+  },
+  "note": "The plain declarator: export const, one identifier, one expression. The initializer is judged by the expression grammar and folds to its value."
+}

package/fixtures/S-ExportSingle/an-expression-initializer/input.ts

@@ -0,0 +1 @@
+export const x = { a: 1, b: [true, null, "s"], c: { d: 2 } };

package/fixtures/S-ExportTypeOnly/type-exports-are-invisible/expect.json

@@ -0,0 +1,19 @@
+{
+  "rules": [
+    "S-ExportTypeOnly",
+    "S-ExportNamed"
+  ],
+  "project": true,
+  "verdicts": {
+    "app.ts": "fold"
+  },
+  "exports": {
+    "app.ts": {
+      "square": {
+        "sides": 4
+      },
+      "x": 4
+    }
+  },
+  "note": "export type { }, an exported type alias and a type-only element of an export list are erased; the gate neither admits nor rejects them. What remains, a value export list and a const, folds."
+}

package/fixtures/S-ExportTypeOnly/type-exports-are-invisible/project/app.ts

@@ -0,0 +1,12 @@
+type Shape = { sides: number };
+interface Named {
+  name: string;
+}
+
+export type { Shape };
+export type Alias = Named;
+
+const square: Shape = { sides: 4 };
+
+export { square, type Named };
+export const x = square.sides;

package/fixtures/S-FactoryBody/consts-then-a-final-return/expect.json

@@ -0,0 +1,38 @@
+{
+  "rules": [
+    "S-FactoryBody",
+    "F-Call",
+    "F-IsolatedRefusal"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "good-shapes.ts": "run",
+    "bad-shapes.ts": "run",
+    "good.ts": "fold",
+    "no-return.ts": "run",
+    "empty.ts": "run"
+  },
+  "rejectRule": {
+    "good-shapes.ts": "F-Eval-Function",
+    "bad-shapes.ts": "F-Eval-Function",
+    "no-return.ts": "F-IsolatedRefusal",
+    "empty.ts": "F-IsolatedRefusal"
+  },
+  "exports": {
+    "good.ts": {
+      "g": {
+        "bucket": {
+          "entityType": "Bucket",
+          "lexicon": "shapes",
+          "props": {
+            "name": "a-base-x"
+          },
+          "attributes": {}
+        }
+      }
+    }
+  },
+  "note": "A factory body is consts, plain or destructured, then a final return, and the return is required: a body without one and an empty body are not interpretable, unlike a project-local function's block (S-FnBody), which yields undefined. Both registration modules run on their own (F-Eval-Function); the good caller folds by interpretation and under ι = isolated the bad callers are F-IsolatedRefusal: step 4 finds the factory not interpretable and step 5 refuses to invoke a project module.",
+  "mode": "isolated"
+}

package/fixtures/S-FactoryBody/consts-then-a-final-return/project/bad-shapes.ts

@@ -0,0 +1,7 @@
+import { Bucket, Composite } from "@tsad/shapes";
+
+export const NoReturn = Composite((props: { name: string }) => {
+  const bucket = new Bucket({ name: props.name });
+}, "NoReturn");
+
+export const Empty = Composite(() => {}, "Empty");

package/fixtures/S-FactoryBody/consts-then-a-final-return/project/empty.ts

@@ -0,0 +1,3 @@
+import { Empty } from "./bad-shapes";
+
+export const e = Empty({});

package/fixtures/S-FactoryBody/consts-then-a-final-return/project/good-shapes.ts

@@ -0,0 +1,7 @@
+import { Bucket, Composite } from "@tsad/shapes";
+
+export const Good = Composite((props: { name: string }) => {
+  const base = `${props.name}-base`;
+  const { suffix } = { suffix: "x" };
+  return { bucket: new Bucket({ name: `${base}-${suffix}` }) };
+}, "Good");

package/fixtures/S-FactoryBody/consts-then-a-final-return/project/good.ts

@@ -0,0 +1,3 @@
+import { Good } from "./good-shapes";
+
+export const g = Good({ name: "a" });

package/fixtures/S-FactoryBody/consts-then-a-final-return/project/no-return.ts

@@ -0,0 +1,3 @@
+import { NoReturn } from "./bad-shapes";
+
+export const n = NoReturn({ name: "a" });

package/fixtures/S-FactoryParams/one-plainly-bound-parameter/expect.json

@@ -0,0 +1,38 @@
+{
+  "rules": [
+    "S-FactoryParams",
+    "F-Call",
+    "F-IsolatedRefusal"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "good-shapes.ts": "run",
+    "bad-shapes.ts": "run",
+    "named.ts": "fold",
+    "rest.ts": "run",
+    "two.ts": "run"
+  },
+  "rejectRule": {
+    "good-shapes.ts": "F-Eval-Function",
+    "bad-shapes.ts": "F-Eval-Function",
+    "rest.ts": "F-IsolatedRefusal",
+    "two.ts": "F-IsolatedRefusal"
+  },
+  "exports": {
+    "named.ts": {
+      "n": {
+        "bucket": {
+          "entityType": "Bucket",
+          "lexicon": "shapes",
+          "props": {
+            "name": "a"
+          },
+          "attributes": {}
+        }
+      }
+    }
+  },
+  "note": "At most one parameter, bound plainly: an identifier or an object pattern with plain elements. A rest parameter and a second parameter each make the factory not interpretable, so under ι = isolated their callers are F-IsolatedRefusal, step 5 refusing what step 4 could not interpret; the registration modules run on their own (F-Eval-Function) and the good caller folds.",
+  "mode": "isolated"
+}

package/fixtures/S-FactoryParams/one-plainly-bound-parameter/project/bad-shapes.ts

@@ -0,0 +1,4 @@
+import { Bucket, Composite } from "@tsad/shapes";
+
+export const Rest = Composite((...all: { name: string }[]) => ({ bucket: new Bucket({ name: all[0].name }) }), "Rest");
+export const Two = Composite((a: { name: string }, b: string) => ({ bucket: new Bucket({ name: a.name + b }) }), "Two");

package/fixtures/S-FactoryParams/one-plainly-bound-parameter/project/good-shapes.ts

@@ -0,0 +1,3 @@
+import { Bucket, Composite } from "@tsad/shapes";
+
+export const Named = Composite(({ name }: { name: string }) => ({ bucket: new Bucket({ name }) }), "Named");

package/fixtures/S-FactoryParams/one-plainly-bound-parameter/project/named.ts

@@ -0,0 +1,3 @@
+import { Named } from "./good-shapes";
+
+export const n = Named({ name: "a" });

package/fixtures/S-FactoryParams/one-plainly-bound-parameter/project/rest.ts

@@ -0,0 +1,3 @@
+import { Rest } from "./bad-shapes";
+
+export const r = Rest({ name: "a" });

package/fixtures/S-FactoryParams/one-plainly-bound-parameter/project/two.ts

@@ -0,0 +1,3 @@
+import { Two } from "./bad-shapes";
+
+export const t = Two({ name: "a" }, "b");

package/fixtures/S-Module/non-exported-statements-are-invisible/expect.json

@@ -0,0 +1,17 @@
+{
+  "rules": [
+    "S-Module"
+  ],
+  "project": true,
+  "verdicts": {
+    "app.ts": "fold"
+  },
+  "exports": {
+    "app.ts": {
+      "x": {
+        "answer": 42
+      }
+    }
+  },
+  "note": "The gate examines only statements carrying export. A non-exported let, an assignment, an if, a class and a bare call are neither admitted nor disqualifiers; they are invisible and their effects are never performed, so the file folds on its one export."
+}

package/fixtures/S-Module/non-exported-statements-are-invisible/project/app.ts

@@ -0,0 +1,13 @@
+let counter = 0;
+counter += 1;
+if (counter > 0) {
+  counter = 2;
+}
+class Hidden {
+  run() {
+    return counter;
+  }
+}
+console.log(new Hidden().run());
+
+export const x = { answer: 42 };

package/fixtures/S-Prop/a-computed-key-rejects/expect.json

@@ -0,0 +1,10 @@
+{
+  "rules": [
+    "S-Prop",
+    "S-Reject"
+  ],
+  "export": "x",
+  "shape": "reject",
+  "fold": "run",
+  "note": "A property key must be a literal key: an identifier, a string or a number. A computed key is a shape rejection even when it would evaluate to a constant."
+}

package/fixtures/S-Prop/a-computed-key-rejects/input.ts

@@ -0,0 +1,3 @@
+const k = "a";
+
+export const x = { [k]: 1 };

package/fixtures/S-Prop/literal-keys/expect.json

@@ -0,0 +1,15 @@
+{
+  "rules": [
+    "S-Prop",
+    "S-Object"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "fold",
+  "value": {
+    "plain": 1,
+    "with-dash": 2,
+    "3": "three"
+  },
+  "note": "The three literal key forms, each with an expression value; the numeric key folds to the string key JavaScript gives it."
+}

package/fixtures/S-Prop/literal-keys/input.ts

@@ -0,0 +1 @@
+export const x = { plain: 1, "with-dash": 2, 3: "three" };

package/fixtures/S-ReExport/named-from-a-sibling/expect.json

@@ -0,0 +1,18 @@
+{
+  "rules": [
+    "S-ReExport",
+    "F-Import"
+  ],
+  "project": true,
+  "verdicts": {
+    "config.ts": "fold",
+    "app.ts": "fold"
+  },
+  "exports": {
+    "app.ts": {
+      "listenOn": 8080,
+      "host": "localhost"
+    }
+  },
+  "note": "A re-export list with a specifier: each element exports the sibling's folded value under the name given, and nothing in this file is evaluated. The values are scalars, so no capture edge is recorded."
+}

package/fixtures/S-ReExport/named-from-a-sibling/project/app.ts

@@ -0,0 +1 @@
+export { port as listenOn, host } from "./config";

package/fixtures/S-ReExport/named-from-a-sibling/project/config.ts

@@ -0,0 +1,2 @@
+export const port = 8080;
+export const host = "localhost";

package/fixtures/S-Shorthand/a-shorthand-property-resolves-as-an-identifier/expect.json

@@ -0,0 +1,14 @@
+{
+  "rules": [
+    "S-Shorthand",
+    "S-Ident"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "fold",
+  "value": {
+    "name": "svc",
+    "port": 80
+  },
+  "note": "A shorthand property is always shape-valid; its name resolves the way an identifier does, here to two top-level consts."
+}

package/fixtures/S-Shorthand/a-shorthand-property-resolves-as-an-identifier/input.ts

@@ -0,0 +1,4 @@
+const name = "svc";
+const port = 80;
+
+export const x = { name, port };

package/fixtures/S-TopConst/an-unexported-const-is-a-binding/expect.json

@@ -0,0 +1,16 @@
+{
+  "rules": [
+    "S-TopConst"
+  ],
+  "project": true,
+  "verdicts": {
+    "binding.ts": "fold",
+    "invisible.ts": "run"
+  },
+  "exports": {
+    "binding.ts": {
+      "x": 42
+    }
+  },
+  "note": "A top-level const with an identifier and an initializer binds its name whether or not it is exported, so binding.ts folds through base. A destructured top-level const is not a binding: q is invisible, and invisible.ts runs because y reads a name nothing bound."
+}