ferrovue 0.7.2 → 0.9.0

package/dist/typescript.js

@@ -27,7 +27,10 @@ export function typesImports(comp, body) {
 }
 export const ONE_NOTHING = "its Rust type is an `Option`, whose `None` cannot be both, as `=== null` and the props sent to the client would need";
 const NULL_OR_UNDEFINED = `a type that is both \`null\` and \`undefined\`: ${ONE_NOTHING}; keep one of them`;
-export function tyOfTs(comp, t, structs, seen = new Set()) {
+export const DATE_PROPS_ONLY = "only a component's own prop may be a `Date`, which the client turns back into one from the prop's declared type: pass an ISO string or a number of milliseconds and build the date with `new Date()` (see the `dates_and_prices` guide)";
+/** A TypeScript type's type, where `dates` says whether it may be a `Date`: a component's own prop,
+ * which may be optional or nullable too. */
+export function tyOfTs(comp, t, structs, seen = new Set(), dates = false) {
     switch (t.type) {
         case "TSStringKeyword":
             return STR;
@@ -38,7 +41,7 @@ export function tyOfTs(comp, t, structs, seen = new Set()) {
         case "TSArrayType":
             return { k: "list", of: tyOfTs(comp, t.elementType, structs, seen) };
         case "TSParenthesizedType":
-            return tyOfTs(comp, t.typeAnnotation, structs, seen);
+            return tyOfTs(comp, t.typeAnnotation, structs, seen, dates);
         case "TSTypeLiteral": {
             const [sig] = t.members;
             const key = sig?.parameters?.[0]?.typeAnnotation?.typeAnnotation;
@@ -49,7 +52,7 @@ export function tyOfTs(comp, t, structs, seen = new Set()) {
         }
         case "TSTypeOperator":
             if (t.operator === "readonly")
-                return tyOfTs(comp, t.typeAnnotation, structs, seen);
+                return tyOfTs(comp, t.typeAnnotation, structs, seen, dates);
             break;
         case "TSLiteralType":
             if (t.literal.type === "StringLiteral" || t.literal.type === "TemplateLiteral")
@@ -69,7 +72,7 @@ export function tyOfTs(comp, t, structs, seen = new Set()) {
                 else if (isNull(u))
                     none = joinAbsence(none, "null");
                 else {
-                    const ty = tyOfTs(comp, u, structs, seen);
+                    const ty = tyOfTs(comp, u, structs, seen, dates);
                     none = joinAbsence(none, absence(ty));
                     tys.push(ty.k === "opt" ? ty.of : ty);
                 }
@@ -103,6 +106,11 @@ export function tyOfTs(comp, t, structs, seen = new Set()) {
             }
             if (comp.childProps.has(name))
                 return { k: "child", name: comp.childProps.get(name) };
+            if (name === "Date" && !comp.aliases.has(name) && !comp.importedTypes.has(name)) {
+                if (!dates)
+                    fail(comp, "FV1806", `a \`Date\` here: ${DATE_PROPS_ONLY}`, t);
+                return { k: "date" };
+            }
             if (comp.floatName !== null && name === comp.floatName)
                 return FLOAT;
             if (comp.inlineName !== null && name === comp.inlineName)
@@ -123,7 +131,7 @@ export function tyOfTs(comp, t, structs, seen = new Set()) {
             if (alias) {
                 if (seen.has(name))
                     fail(comp, "FV0314", `type \`${name}\` refers to itself through an alias`, t);
-                return tyOfTs(comp, alias, structs, new Set(seen).add(name));
+                return tyOfTs(comp, alias, structs, new Set(seen).add(name), dates);
             }
             return fail(comp, "FV0315", `unsupported prop type \`${name}\`: declare it as an interface in the component, or import it from a \`.ts\` file`, t);
         }
@@ -233,15 +241,16 @@ export function reachType(name) {
         throw e;
     }
 }
-/** Translate an interface a component declares, the first time something the server renders reaches it. */
-export function reachLocal(comp, name) {
+/** Translate an interface a component declares, the first time something the server renders
+ * reaches it; `dates` when it is the component's props. */
+export function reachLocal(comp, name, dates = false) {
     const decl = comp.typeDecls.get(name);
     if (decl === undefined || comp.reached.has(name))
         return;
     comp.reached.add(name);
     try {
         refusePrelude(comp, { name, node: decl.node });
-        comp.structs.set(name, structOf(comp, name, decl.members, comp.structs, true));
+        comp.structs.set(name, structOf(comp, name, decl.members, comp.structs, true, dates));
     }
     catch (e) {
         comp.reached.delete(name);
@@ -265,6 +274,35 @@ export function requireWhole(comp, ty, seen = new Set()) {
     for (const f of st.fields)
         requireWhole(owner, f.ty, seen);
 }
+/** Whether a value of the type holds a `Date` inside a list, a dictionary or an object. */
+export function holdsDate(comp, ty, seen = new Set()) {
+    if (ty.k === "date")
+        return true;
+    if (ty.k === "opt" || ty.k === "list" || ty.k === "record")
+        return holdsDate(comp, ty.of, seen);
+    if (ty.k === "child") {
+        const child = childOf(ty.name);
+        if (seen.has(child))
+            return false;
+        seen.add(child);
+        return child.props.fields.some((f) => holdsDate(child, f.ty, seen));
+    }
+    if (ty.k !== "struct")
+        return false;
+    const { st, owner } = lookupStruct(comp, ty);
+    if (st === undefined || seen.has(st))
+        return false;
+    seen.add(st);
+    return st.fields.some((f) => holdsDate(owner, f.ty, seen));
+}
+/** Refuse a prop that holds a `Date` anywhere but as itself, optional or nullable. */
+export function refuseNestedDates(comp, fields, node) {
+    for (const f of fields) {
+        const of = f.ty.k === "opt" ? f.ty.of : f.ty;
+        if (of.k !== "date" && holdsDate(comp, of))
+            fail(comp, "FV1806", `\`${f.js}\` holds a \`Date\` inside a list or an object: ${DATE_PROPS_ONLY}`, node);
+    }
+}
 /** Whether `types.rs` holds the type: one built from a constant list, or a declared one something reached. */
 export function typeWritten(name) {
     return !ctx.typeDecls.has(name) || ctx.typeReached.has(name);
@@ -294,12 +332,12 @@ export function lookupStruct(comp, ty) {
     reachLocal(comp, ty.name);
     return { st: comp.structs.get(ty.name), owner: comp, path: "" };
 }
-export function structOf(comp, name, members, structs, lenient = false) {
+export function structOf(comp, name, members, structs, lenient = false, dates = false) {
     const fields = [];
     const refused = new Map();
     for (const m of members) {
         try {
-            fields.push(fieldOf(comp, name, m, structs));
+            fields.push(fieldOf(comp, name, m, structs, dates));
         }
         catch (e) {
             if (!lenient || !(e instanceof GenError))
@@ -318,11 +356,11 @@ function memberKey(m) {
         return "";
     return m.key.type === "Identifier" ? m.key.name : m.key.type === "StringLiteral" ? m.key.value : "";
 }
-function fieldOf(comp, name, m, structs) {
+function fieldOf(comp, name, m, structs, dates) {
     if (m.type !== "TSPropertySignature" || m.key.type !== "Identifier") {
         fail(comp, "FV0320", `\`${name}\` may only hold plain named fields`, m);
     }
-    const base = tyOfTs(comp, m.typeAnnotation.typeAnnotation, structs);
+    const base = tyOfTs(comp, m.typeAnnotation.typeAnnotation, structs, new Set(), dates);
     if (m.optional && absence(base) === "null") {
         fail(comp, "FV0321", `\`${m.key.name}?: T | null\` may be absent, which is \`undefined\`, or \`null\`: ${ONE_NOTHING}; declare it \`${m.key.name}: T | null\` or \`${m.key.name}?: T\``, m);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ferrovue",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "Vue templates compiled to Rust render functions: server-side rendering with no JavaScript at run time",
   "license": "MIT OR Apache-2.0",
   "repository": {
@@ -77,11 +77,11 @@
   },
   "dependencies": {
     "@babel/parser": "^7.29.9",
-    "@intlify/message-compiler": "11.4.13",
-    "@vue/compiler-sfc": "3.5.43",
-    "@vue/shared": "3.5.43",
+    "@intlify/message-compiler": "11.4.15",
+    "@vue/compiler-sfc": "3.5.44",
+    "@vue/shared": "3.5.44",
     "generic-names": "^4.0.0",
-    "postcss": "^8.5.29",
+    "postcss": "^8.5.30",
     "postcss-modules-extract-imports": "^3.1.0",
     "postcss-modules-local-by-default": "^4.2.0",
     "postcss-modules-scope": "^3.2.1",
@@ -89,30 +89,30 @@
     "source-map-js": "^1.2.2"
   },
   "devDependencies": {
-    "@unhead/vue": "^3.4.2",
-    "@vue/language-core": "3.3.12",
-    "@vue/language-service": "3.3.12",
-    "@vue/server-renderer": "3.5.43",
-    "pinia": "^4.0.3",
-    "playwright": "1.64.0",
+    "@unhead/vue": "^3.4.3",
+    "@vue/language-core": "3.3.13",
+    "@vue/language-service": "3.3.13",
+    "@vue/server-renderer": "3.5.44",
+    "pinia": "^4.1.0",
+    "playwright": "1.64.1",
     "typescript": "^7.0.2",
     "typescript-js": "npm:typescript@6.0.3",
     "vite": "^8.3.4",
-    "vitest": "^5.0.3",
+    "vitest": "^5.0.5",
     "vscode-uri": "3.2.0",
-    "vue": "3.5.43",
-    "vue-i18n": "11.4.13",
-    "vue-router": "^5.3.1"
+    "vue": "3.5.44",
+    "vue-i18n": "11.4.15",
+    "vue-router": "^5.4.0"
   },
   "peerDependencies": {
-    "@unhead/vue": "~3.4.2",
+    "@unhead/vue": "~3.4.3",
     "@vue/language-core": "^3.3.0",
-    "pinia": "~4.0.3",
+    "pinia": "~4.1.0",
     "vite": ">=6",
     "vitest": ">=5",
-    "vue": "~3.5.43",
-    "vue-i18n": "~11.4.13",
-    "vue-router": "~5.3.1"
+    "vue": "~3.5.44",
+    "vue-i18n": "~11.4.15",
+    "vue-router": "~5.4.0"
   },
   "peerDependenciesMeta": {
     "@unhead/vue": {

package/schema.json

@@ -144,6 +144,12 @@
       "markdownDescription": "The Rust type a `TrustedHtml` prop is, which must implement `ferrovue::TrustedHtml`, e.g. `crate::sanitize::SafeHtml`. A type that borrows names the props' lifetime, `'a`: `crate::render::Trusted<'a>`. `ferrovue::InlineHtml` makes every `TrustedHtml` prop inline HTML. Without it, only an `InlineHtml` prop may reach `v-html`.",
       "type": "string"
     },
+    "dateType": {
+      "description": "The Rust type a `Date` prop is, which must implement `ferrovue::JsTime`: `ferrovue::JsDate` by default, or `chrono::DateTime<chrono::Utc>` with the crate's `chrono` feature.",
+      "markdownDescription": "The Rust type a `Date` prop is, which must implement `ferrovue::JsTime`: `ferrovue::JsDate` by default, or `chrono::DateTime<chrono::Utc>` with the crate's `chrono` feature.",
+      "type": "string",
+      "default": "ferrovue::JsDate"
+    },
     "routes": {
       "description": "A JSON file listing the app's routes as vue-router paths (`/users/:id`), which `<RouterLink>` resolves against, or `{ pages }`: a folder of pages whose file names give the routes, as vue-router's file-based routing reads them. Without it, a component cannot use `<RouterLink>`.",
       "markdownDescription": "A JSON file listing the app's routes as vue-router paths (`/users/:id`), which `<RouterLink>` resolves against, or `{ pages }`: a folder of pages whose file names give the routes, as vue-router's file-based routing reads them. Without it, a component cannot use `<RouterLink>`.",