@happyvertical/smrt-core 0.57.45 → 0.57.47

package/dist/manifest/object-declarations.js

@@ -0,0 +1,161 @@
+//#region src/manifest/object-declarations.ts
+function compareText(left, right) {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+}
+function normalizeSourcePath(filePath) {
+	return filePath.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+}
+function isAbsoluteSourcePath(filePath) {
+	return filePath.startsWith("/") || /^[A-Za-z]:\//.test(filePath);
+}
+/**
+* The value as it survives a manifest JSON round trip. An in-memory scanned
+* listing (Vite plugin) is merged with dependency listings read from
+* `dist/manifest.json`; `undefined`-valued keys exist only in the former, so
+* comparing raw objects would keep the same class apart.
+*/
+function wireShape(value) {
+	const json = JSON.stringify(value);
+	return json === void 0 ? null : JSON.parse(json);
+}
+/** JSON with object keys sorted at every depth, for structural comparison. */
+function canonicalJson(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.keys(value).sort(compareText).map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+	return JSON.stringify(value) ?? "null";
+}
+/**
+* The identity of the class a manifest listing describes.
+*
+* Two listings are the same class only when they name the same class in the
+* same absolute declaring source file AND describe the same fields. A path is
+* only machine-local evidence (separately built packages can share a
+* `/app/src/...` layout), so the field shape the declaration is rendered from
+* must agree too: listings that collapse always render identical
+* declarations, and a stale or unrelated listing stays separate instead of
+* silently supplying (or losing) fields. A relative `filePath` is relative to
+* whichever root scanned it, so two equal relative paths from different
+* packages may be different files; such listings fall back to their qualified
+* name (or manifest key), which keeps them distinct.
+*/
+function objectDeclarationIdentity(manifestKey, obj) {
+	const filePath = typeof obj.filePath === "string" ? normalizeSourcePath(obj.filePath) : "";
+	if (filePath && isAbsoluteSourcePath(filePath)) return `source\0${filePath}\0${obj.className}\0${canonicalJson(wireShape(obj.fields ?? {}))}`;
+	return `listing\0${obj.qualifiedName || manifestKey}`;
+}
+/**
+* Manifest entries in the deterministic qualified-identity order every
+* declaration emitter shares (#2749): qualified name (or manifest key), then
+* manifest key.
+*/
+function orderedEntries(manifest) {
+	return Object.entries(manifest.objects ?? {}).sort(([leftKey, left], [rightKey, right]) => compareText(left.qualifiedName || leftKey, right.qualifiedName || rightKey) || compareText(leftKey, rightKey));
+}
+function declarationPackage(manifestKey, obj) {
+	if (obj.packageName) return obj.packageName;
+	const qualifiedName = obj.qualifiedName || manifestKey;
+	const separator = qualifiedName.lastIndexOf(":");
+	return separator > 0 ? qualifiedName.slice(0, separator) : void 0;
+}
+/** `@ergot/market-core` -> `ErgotMarketCore`, a valid identifier prefix. */
+function packageIdentifierPrefix(packageName) {
+	if (!packageName) return "";
+	const prefix = packageName.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+	return /^[0-9]/.test(prefix) ? `_${prefix}` : prefix;
+}
+/**
+* Select one declaration per class described by the manifest, in deterministic
+* qualified-identity order of each class's first listing, and name each one.
+*
+* Naming follows the qualified identity when simple names collide (#3115): a
+* class whose simple name is unique keeps `${className}Data`; distinct classes
+* sharing a simple name each get a package-qualified name
+* (`@ergot/market-core:LicenseSale` -> `ErgotMarketCoreLicenseSaleData`) and
+* none of them keeps the bare name, which would otherwise silently merge two
+* classes' fields through TypeScript declaration merging. Every simple name
+* is reserved first, and a qualified name that is still taken (or a stem with
+* no known package) gets a stable numeric suffix, so every emitted name is
+* unique and independent of manifest insertion order.
+*
+* The package prefix is the package of the declaration's FIRST listing in
+* qualified-identity order. When one class is relisted by consumer packages
+* (#3296) that is not necessarily the declaring package, and it can change
+* when a relisting dependency is added or removed; the collision warning
+* names every listing so a consumer can tell. A collision group also forms
+* when one class's listings disagree on fields (a stale relisting), which the
+* warning describes as well.
+*/
+function createObjectDeclarationIndex(manifest) {
+	const byIdentity = /* @__PURE__ */ new Map();
+	const byObject = /* @__PURE__ */ new Map();
+	for (const [manifestKey, obj] of orderedEntries(manifest)) {
+		const identity = objectDeclarationIdentity(manifestKey, obj);
+		const existing = byIdentity.get(identity);
+		if (existing) {
+			existing.manifestKeys.push(manifestKey);
+			byObject.set(obj, existing);
+			continue;
+		}
+		const declaration = {
+			interfaceName: `${obj.className}Data`,
+			obj,
+			manifestKey,
+			manifestKeys: [manifestKey]
+		};
+		byIdentity.set(identity, declaration);
+		byObject.set(obj, declaration);
+	}
+	const declarations = [...byIdentity.values()];
+	const byClassName = /* @__PURE__ */ new Map();
+	for (const declaration of declarations) {
+		const group = byClassName.get(declaration.obj.className) ?? [];
+		group.push(declaration);
+		byClassName.set(declaration.obj.className, group);
+	}
+	const used = /* @__PURE__ */ new Set();
+	for (const className of byClassName.keys()) used.add(`${className}Data`);
+	const collisions = [];
+	for (const [className, group] of byClassName) {
+		if (group.length === 1) continue;
+		for (const declaration of group) {
+			const stem = `${packageIdentifierPrefix(declarationPackage(declaration.manifestKey, declaration.obj))}${className}`;
+			let interfaceName = `${stem}Data`;
+			for (let suffix = 2; used.has(interfaceName); suffix += 1) interfaceName = `${stem}${suffix}Data`;
+			used.add(interfaceName);
+			declaration.interfaceName = interfaceName;
+		}
+		collisions.push({
+			className,
+			declarations: group.map((declaration) => ({
+				interfaceName: declaration.interfaceName,
+				objectRefs: declaration.manifestKeys.map((key) => manifest.objects[key]?.qualifiedName || key)
+			}))
+		});
+	}
+	return {
+		declarations,
+		collisions,
+		interfaceNameFor: (obj) => byObject.get(obj)?.interfaceName ?? `${obj.className}Data`
+	};
+}
+/**
+* Select one declaration per class described by the manifest; see
+* {@link createObjectDeclarationIndex} for identity and naming.
+*/
+function selectObjectDeclarations(manifest) {
+	return createObjectDeclarationIndex(manifest).declarations;
+}
+/**
+* Report simple-name collisions once per generation, naming the qualified
+* interface each class was given, so a consumer that referenced the bare
+* name learns which one to use (#3115).
+*/
+function warnObjectDeclarationCollisions(index, log) {
+	for (const { className, declarations } of index.collisions) log(`[smrt:types] ${declarations.length} declarations share the class name ${JSON.stringify(className)} (distinct classes, or one class whose listings disagree on fields); generated row types use qualified names instead of ${className}Data: ` + declarations.map(({ interfaceName, objectRefs }) => `${interfaceName} (${objectRefs.join(", ")})`).join("; "));
+}
+//#endregion
+export { createObjectDeclarationIndex, objectDeclarationIdentity, selectObjectDeclarations, warnObjectDeclarationCollisions };
+
+//# sourceMappingURL=object-declarations.js.map

package/dist/manifest/object-declarations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-declarations.js","names":[],"sources":["../../src/manifest/object-declarations.ts"],"sourcesContent":["/**\n * Manifest -> generated object-type declaration selection.\n *\n * Every emitter of the per-object `XData` row interfaces (the physical\n * `smrt-objects.d.ts` / `smrt-types.d.ts` prebuild files, the Vite ambient\n * `virtual-modules.d.ts`, the `@smrt/types` virtual module in server and client\n * mode, and the consumer fallback module) reads this selection, so they agree\n * on how many declarations exist and in which order.\n *\n * A declaration describes one CLASS, not one manifest listing. An aggregated\n * consumer manifest can list one class several times: when workspace libraries\n * are built, each library that consumes another package's model scans that\n * model's source under its own package name (#3110), so the class appears once\n * under its declaring package and again under every consumer package. Those\n * listings name the same declaring source file and class with the same fields,\n * so they collapse to a single declaration (#3296). Listings without an\n * absolute source path, or whose fields disagree, cannot be proven to be the\n * same class and keep one declaration each.\n *\n * Pure and dependency-free: the scanner, the Vite plugin, the consumer plugin\n * and the prebuild CLI all import it.\n */\n\nimport type {\n  SmartObjectDefinition,\n  SmartObjectManifest,\n} from '../scanner/types.js';\n\n/** One generated object-type declaration and the listings it describes. */\nexport interface ObjectDeclaration {\n  /**\n   * Interface name emitted for the class's row payload: `ProductData`, or a\n   * package-qualified name when distinct classes share the simple name.\n   */\n  interfaceName: string;\n  /**\n   * The listing the declaration is rendered from: the first listing in\n   * deterministic qualified-identity order. Every collapsed listing has the\n   * same fields, so the choice never changes the declared type (only, at\n   * most, the order its properties are written in).\n   */\n  obj: SmartObjectDefinition;\n  /** Manifest key of {@link obj}. */\n  manifestKey: string;\n  /** Every manifest key that names this class, in qualified-identity order. */\n  manifestKeys: string[];\n}\n\nfunction compareText(left: string, right: string): number {\n  if (left < right) return -1;\n  if (left > right) return 1;\n  return 0;\n}\n\nfunction normalizeSourcePath(filePath: string): string {\n  return filePath.replace(/\\\\/g, '/').replace(/\\/{2,}/g, '/');\n}\n\nfunction isAbsoluteSourcePath(filePath: string): boolean {\n  return filePath.startsWith('/') || /^[A-Za-z]:\\//.test(filePath);\n}\n\n/**\n * The value as it survives a manifest JSON round trip. An in-memory scanned\n * listing (Vite plugin) is merged with dependency listings read from\n * `dist/manifest.json`; `undefined`-valued keys exist only in the former, so\n * comparing raw objects would keep the same class apart.\n */\nfunction wireShape(value: unknown): unknown {\n  const json = JSON.stringify(value);\n  return json === undefined ? null : JSON.parse(json);\n}\n\n/** JSON with object keys sorted at every depth, for structural comparison. */\nfunction canonicalJson(value: unknown): string {\n  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;\n  if (value && typeof value === 'object') {\n    return `{${Object.keys(value as Record<string, unknown>)\n      .sort(compareText)\n      .map(\n        (key) =>\n          `${JSON.stringify(key)}:${canonicalJson((value as Record<string, unknown>)[key])}`,\n      )\n      .join(',')}}`;\n  }\n  return JSON.stringify(value) ?? 'null';\n}\n\n/**\n * The identity of the class a manifest listing describes.\n *\n * Two listings are the same class only when they name the same class in the\n * same absolute declaring source file AND describe the same fields. A path is\n * only machine-local evidence (separately built packages can share a\n * `/app/src/...` layout), so the field shape the declaration is rendered from\n * must agree too: listings that collapse always render identical\n * declarations, and a stale or unrelated listing stays separate instead of\n * silently supplying (or losing) fields. A relative `filePath` is relative to\n * whichever root scanned it, so two equal relative paths from different\n * packages may be different files; such listings fall back to their qualified\n * name (or manifest key), which keeps them distinct.\n */\nexport function objectDeclarationIdentity(\n  manifestKey: string,\n  obj: SmartObjectDefinition,\n): string {\n  const filePath =\n    typeof obj.filePath === 'string' ? normalizeSourcePath(obj.filePath) : '';\n  if (filePath && isAbsoluteSourcePath(filePath)) {\n    return `source\\0${filePath}\\0${obj.className}\\0${canonicalJson(wireShape(obj.fields ?? {}))}`;\n  }\n  return `listing\\0${obj.qualifiedName || manifestKey}`;\n}\n\n/**\n * Manifest entries in the deterministic qualified-identity order every\n * declaration emitter shares (#2749): qualified name (or manifest key), then\n * manifest key.\n */\nfunction orderedEntries(\n  manifest: SmartObjectManifest,\n): Array<[string, SmartObjectDefinition]> {\n  return Object.entries(manifest.objects ?? {}).sort(\n    ([leftKey, left], [rightKey, right]) =>\n      compareText(\n        left.qualifiedName || leftKey,\n        right.qualifiedName || rightKey,\n      ) || compareText(leftKey, rightKey),\n  );\n}\n\nfunction declarationPackage(\n  manifestKey: string,\n  obj: SmartObjectDefinition,\n): string | undefined {\n  if (obj.packageName) return obj.packageName;\n  const qualifiedName = obj.qualifiedName || manifestKey;\n  const separator = qualifiedName.lastIndexOf(':');\n  return separator > 0 ? qualifiedName.slice(0, separator) : undefined;\n}\n\n/** `@ergot/market-core` -> `ErgotMarketCore`, a valid identifier prefix. */\nfunction packageIdentifierPrefix(packageName: string | undefined): string {\n  if (!packageName) return '';\n  const prefix = packageName\n    .split(/[^A-Za-z0-9]+/)\n    .filter(Boolean)\n    .map((part) => part[0].toUpperCase() + part.slice(1))\n    .join('');\n  return /^[0-9]/.test(prefix) ? `_${prefix}` : prefix;\n}\n\n/**\n * Distinct classes that share one simple class name (#3115), with the\n * qualified interface name each was given.\n */\nexport interface ObjectDeclarationCollision {\n  className: string;\n  /** Each declaration's name and every listing it describes. */\n  declarations: Array<{ interfaceName: string; objectRefs: string[] }>;\n}\n\n/** The declaration selection plus a lookup from any listing to its name. */\nexport interface ObjectDeclarationIndex {\n  declarations: ObjectDeclaration[];\n  collisions: ObjectDeclarationCollision[];\n  /**\n   * The declared row interface for a listing in this manifest (by object\n   * reference). A collection class resolves through the caller to its item\n   * listing first; an object outside the manifest falls back to its simple\n   * `${className}Data`.\n   */\n  interfaceNameFor(obj: SmartObjectDefinition): string;\n}\n\n/**\n * Select one declaration per class described by the manifest, in deterministic\n * qualified-identity order of each class's first listing, and name each one.\n *\n * Naming follows the qualified identity when simple names collide (#3115): a\n * class whose simple name is unique keeps `${className}Data`; distinct classes\n * sharing a simple name each get a package-qualified name\n * (`@ergot/market-core:LicenseSale` -> `ErgotMarketCoreLicenseSaleData`) and\n * none of them keeps the bare name, which would otherwise silently merge two\n * classes' fields through TypeScript declaration merging. Every simple name\n * is reserved first, and a qualified name that is still taken (or a stem with\n * no known package) gets a stable numeric suffix, so every emitted name is\n * unique and independent of manifest insertion order.\n *\n * The package prefix is the package of the declaration's FIRST listing in\n * qualified-identity order. When one class is relisted by consumer packages\n * (#3296) that is not necessarily the declaring package, and it can change\n * when a relisting dependency is added or removed; the collision warning\n * names every listing so a consumer can tell. A collision group also forms\n * when one class's listings disagree on fields (a stale relisting), which the\n * warning describes as well.\n */\nexport function createObjectDeclarationIndex(\n  manifest: SmartObjectManifest,\n): ObjectDeclarationIndex {\n  const byIdentity = new Map<string, ObjectDeclaration>();\n  const byObject = new Map<SmartObjectDefinition, ObjectDeclaration>();\n  for (const [manifestKey, obj] of orderedEntries(manifest)) {\n    const identity = objectDeclarationIdentity(manifestKey, obj);\n    const existing = byIdentity.get(identity);\n    if (existing) {\n      existing.manifestKeys.push(manifestKey);\n      byObject.set(obj, existing);\n      continue;\n    }\n    const declaration: ObjectDeclaration = {\n      interfaceName: `${obj.className}Data`,\n      obj,\n      manifestKey,\n      manifestKeys: [manifestKey],\n    };\n    byIdentity.set(identity, declaration);\n    byObject.set(obj, declaration);\n  }\n  const declarations = [...byIdentity.values()];\n\n  const byClassName = new Map<string, ObjectDeclaration[]>();\n  for (const declaration of declarations) {\n    const group = byClassName.get(declaration.obj.className) ?? [];\n    group.push(declaration);\n    byClassName.set(declaration.obj.className, group);\n  }\n\n  // Every simple name is reserved, including a colliding one: no member of a\n  // collision group may keep it, even when its package is unknown and its\n  // qualified stem is just the class name.\n  const used = new Set<string>();\n  for (const className of byClassName.keys()) used.add(`${className}Data`);\n  const collisions: ObjectDeclarationCollision[] = [];\n  for (const [className, group] of byClassName) {\n    if (group.length === 1) continue;\n    for (const declaration of group) {\n      const stem = `${packageIdentifierPrefix(\n        declarationPackage(declaration.manifestKey, declaration.obj),\n      )}${className}`;\n      let interfaceName = `${stem}Data`;\n      for (let suffix = 2; used.has(interfaceName); suffix += 1) {\n        interfaceName = `${stem}${suffix}Data`;\n      }\n      used.add(interfaceName);\n      declaration.interfaceName = interfaceName;\n    }\n    collisions.push({\n      className,\n      declarations: group.map((declaration) => ({\n        interfaceName: declaration.interfaceName,\n        objectRefs: declaration.manifestKeys.map(\n          (key) => manifest.objects[key]?.qualifiedName || key,\n        ),\n      })),\n    });\n  }\n\n  return {\n    declarations,\n    collisions,\n    interfaceNameFor: (obj) =>\n      byObject.get(obj)?.interfaceName ?? `${obj.className}Data`,\n  };\n}\n\n/**\n * Select one declaration per class described by the manifest; see\n * {@link createObjectDeclarationIndex} for identity and naming.\n */\nexport function selectObjectDeclarations(\n  manifest: SmartObjectManifest,\n): ObjectDeclaration[] {\n  return createObjectDeclarationIndex(manifest).declarations;\n}\n\n/**\n * Report simple-name collisions once per generation, naming the qualified\n * interface each class was given, so a consumer that referenced the bare\n * name learns which one to use (#3115).\n */\nexport function warnObjectDeclarationCollisions(\n  index: ObjectDeclarationIndex,\n  log: (message: string) => void,\n): void {\n  for (const { className, declarations } of index.collisions) {\n    log(\n      `[smrt:types] ${declarations.length} declarations share the class name ${JSON.stringify(className)} ` +\n        '(distinct classes, or one class whose listings disagree on fields); ' +\n        `generated row types use qualified names instead of ${className}Data: ` +\n        declarations\n          .map(\n            ({ interfaceName, objectRefs }) =>\n              `${interfaceName} (${objectRefs.join(', ')})`,\n          )\n          .join('; '),\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/manifest/static-manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"static-manifest.d.ts","sourceRoot":"","sources":["../../src/manifest/static-manifest.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,eAAO,MAAM,cAAc,EAAE,mBAm1DnB,CAAC;AAEX,eAAe,cAAc,CAAC"}
+{"version":3,"file":"static-manifest.d.ts","sourceRoot":"","sources":["../../src/manifest/static-manifest.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,eAAO,MAAM,cAAc,EAAE,mBAq1DnB,CAAC;AAEX,eAAe,cAAc,CAAC"}

package/dist/manifest/static-manifest.js

@@ -3,7 +3,7 @@ var staticManifest = {
 	"version": "1.0.0",
 	"timestamp": 0,
 	"packageName": "@happyvertical/smrt-core",
-	"packageVersion": "0.57.45",
+	"packageVersion": "0.57.47",
 	"objects": {
 		"@happyvertical/smrt-core:SmrtClass": {
 			"name": "smrtclass",
@@ -921,7 +921,8 @@ var staticManifest = {
 						{
 							"name": "opts",
 							"type": "JunctionAttachOptions",
-							"optional": true
+							"optional": true,
+							"resolvedType": "Record<string, unknown>"
 						}
 					],
 					"returnType": "Promise<TItem>",
@@ -969,7 +970,8 @@ var staticManifest = {
 						{
 							"name": "opts",
 							"type": "JunctionAttachOptions",
-							"optional": true
+							"optional": true,
+							"resolvedType": "Record<string, unknown>"
 						}
 					],
 					"returnType": "Promise<void>",