@nyrra/prismantix-cli 0.0.4-next.20 → 0.0.4-next.22

package/dist/foundry-import/names.js

@@ -0,0 +1,83 @@
+const objectApiNamePattern = /^[a-zA-Z][a-zA-Z0-9]{0,99}$/;
+const apiNamePattern = /^[a-zA-Z][a-zA-Z0-9_]{0,99}$/;
+const reservedApiNames = new Set([
+    "ontology",
+    "object",
+    "property",
+    "link",
+    "relation",
+    "rid",
+    "primarykey",
+    "typeid",
+    "ontologyobject",
+]);
+export function addSanitizationDiagnostic(diagnostics, path, original, sanitized) {
+    if (original === sanitized) {
+        return;
+    }
+    diagnostics.push({
+        code: "coerced.apiName",
+        message: `API name ${original} was emitted as ${sanitized}.`,
+        path,
+        severity: "warning",
+    });
+}
+export function sanitizeApiName(name, mode) {
+    const candidate = sanitizedCandidate(name, mode);
+    if (isAllowedApiName(candidate, mode)) {
+        return candidate;
+    }
+    return prefixedApiName(candidate, mode);
+}
+export function createNameAllocator() {
+    const seen = new Map();
+    return (name) => {
+        const count = seen.get(name) ?? 0;
+        seen.set(name, count + 1);
+        return count === 0 ? name : `${name}${count + 1}`;
+    };
+}
+function originalComment(name) {
+    return name.original === name.sanitized
+        ? `// ${name.original}`
+        : `// ${name.original} -> ${name.sanitized}`;
+}
+export function entityComment(name, rid) {
+    return rid
+        ? `${originalComment(name)}\n// rid: ${rid}`
+        : originalComment(name);
+}
+export function safePropertyKey(key) {
+    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+export function toPascalCase(value) {
+    const words = value.match(/[a-zA-Z0-9]+/g) ?? ["Imported"];
+    return words.map(capitalize).join("") || "Imported";
+}
+function capitalize(value) {
+    return value.length === 0
+        ? value
+        : `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}`;
+}
+function sanitizedCandidate(name, mode) {
+    const words = name.match(/[a-zA-Z0-9]+/g) ?? ["Imported"];
+    const joined = mode === "object" ? objectName(words) : apiName(words);
+    return (joined === "" ? "Imported" : joined).slice(0, 100);
+}
+function objectName(words) {
+    return words.map(capitalize).join("");
+}
+function apiName(words) {
+    const [firstWord = "imported", ...remainingWords] = words;
+    return `${firstWord.replace(/^[0-9]+/, "")}${remainingWords
+        .map(capitalize)
+        .join("")}`;
+}
+function isAllowedApiName(candidate, mode) {
+    const pattern = mode === "object" ? objectApiNamePattern : apiNamePattern;
+    return (pattern.test(candidate) && !reservedApiNames.has(candidate.toLowerCase()));
+}
+function prefixedApiName(candidate, mode) {
+    const prefix = mode === "object" ? "Imported" : "imported";
+    return `${prefix}${capitalize(candidate)}`.slice(0, 100);
+}

package/dist/foundry-import/objects.d.ts

@@ -0,0 +1,9 @@
+import type { ConversionDiagnostic, FoundryObjectType, NormalizedObject } from "./types.js";
+interface ObjectNormalizationContext {
+    readonly diagnostics: ConversionDiagnostic[];
+    readonly objectNameAllocator: (name: string) => string;
+    readonly variableNameAllocator: (name: string) => string;
+}
+export declare function normalizeObject(objectType: FoundryObjectType, objectIndex: number, context: ObjectNormalizationContext): NormalizedObject;
+export {};
+//# sourceMappingURL=objects.d.ts.map

package/dist/foundry-import/objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objects.d.ts","sourceRoot":"","sources":["../../src/foundry-import/objects.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACX,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,MAAM,YAAY,CAAC;AAQpB,UAAU,0BAA0B;IACnC,QAAQ,CAAC,WAAW,EAAE,oBAAoB,EAAE,CAAC;IAC7C,QAAQ,CAAC,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACvD,QAAQ,CAAC,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CACzD;AAED,wBAAgB,eAAe,CAC9B,UAAU,EAAE,iBAAiB,EAC7B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,0BAA0B,GACjC,gBAAgB,CAiDlB"}

package/dist/foundry-import/objects.js

@@ -0,0 +1,128 @@
+import { addSanitizationDiagnostic, createNameAllocator, sanitizeApiName, toPascalCase, } from "./names.js";
+import { normalizeProperty } from "./properties.js";
+import { displayNameFor, normalizeDescription, normalizeStatus, requiredString, } from "./utils.js";
+export function normalizeObject(objectType, objectIndex, context) {
+    const apiName = normalizeObjectApiName(objectType, objectIndex, context.objectNameAllocator, context.diagnostics);
+    const properties = normalizeObjectProperties(objectType, objectIndex, context);
+    const propertiesById = new Map(properties.map((property) => [property.originalId, property]));
+    addObjectMetadataDiagnostics(objectType, objectIndex, apiName.original, context.diagnostics);
+    const keys = resolveObjectKeys(objectType, propertiesById);
+    addKeyDiagnostics(objectType, objectIndex, apiName.original, keys.primaryKeyProperty, keys.titleProperty, context.diagnostics);
+    const fallbackProperty = properties[0];
+    return {
+        apiName,
+        description: objectDescription(objectType),
+        displayName: objectDisplayName(objectType, apiName.sanitized),
+        pluralDisplayName: pluralDisplayNameFor(objectType, apiName.sanitized),
+        primaryKeyPropertyApiName: keyPropertyApiName(keys.primaryKeyProperty, fallbackProperty),
+        properties,
+        propertiesById,
+        rid: objectType.rid,
+        status: normalizeStatus(objectType.status),
+        titlePropertyApiName: titlePropertyApiName(keys, fallbackProperty),
+        variableName: context.variableNameAllocator(toPascalCase(apiName.sanitized)),
+    };
+}
+function normalizeObjectApiName(objectType, objectIndex, nameAllocator, diagnostics) {
+    const original = requiredString(objectType.apiName, `$.objectTypes[${objectIndex}].apiName`, diagnostics, `Object${objectIndex + 1}`);
+    const sanitized = nameAllocator(sanitizeApiName(original, "object"));
+    addSanitizationDiagnostic(diagnostics, `$.objectTypes[${objectIndex}].apiName`, original, sanitized);
+    return { original, sanitized };
+}
+function pluralDisplayNameFor(objectType, apiName) {
+    return (objectType.displayMetadata?.pluralDisplayName ??
+        `${displayNameFor(objectType.displayMetadata, apiName)}s`);
+}
+function resolveObjectKeys(objectType, propertiesById) {
+    return {
+        primaryKeyProperty: resolveProperty(objectType.primaryKeys?.[0], propertiesById),
+        titleProperty: resolveProperty(objectType.titlePropertyId, propertiesById),
+    };
+}
+function objectDescription(objectType) {
+    return normalizeDescription(objectType.displayMetadata?.description);
+}
+function objectDisplayName(objectType, apiName) {
+    return displayNameFor(objectType.displayMetadata, apiName);
+}
+function keyPropertyApiName(property, fallbackProperty) {
+    return (property ?? fallbackProperty)?.apiName.sanitized ?? "id";
+}
+function titlePropertyApiName(keys, fallbackProperty) {
+    return ((keys.titleProperty ?? keys.primaryKeyProperty ?? fallbackProperty)?.apiName
+        .sanitized ?? "id");
+}
+function normalizeObjectProperties(objectType, objectIndex, context) {
+    const propertyNameAllocator = createNameAllocator();
+    return (objectType.properties ?? []).map((property, propertyIndex) => normalizeProperty(property, `$.objectTypes[${objectIndex}].properties[${propertyIndex}]`, propertyNameAllocator, context.diagnostics));
+}
+function addObjectMetadataDiagnostics(objectType, objectIndex, apiName, diagnostics) {
+    addObjectInterfacesDiagnostic(objectType, objectIndex, apiName, diagnostics);
+    addObjectTypeGroupsDiagnostic(objectType, objectIndex, apiName, diagnostics);
+}
+function addObjectInterfacesDiagnostic(objectType, objectIndex, apiName, diagnostics) {
+    if ((objectType.interfaces?.length ?? 0) === 0) {
+        return;
+    }
+    diagnostics.push({
+        code: "partial.objectInterfaces",
+        message: `Object ${apiName} implements interfaces; interface implementation bindings are not emitted in this first pass.`,
+        path: `$.objectTypes[${objectIndex}].interfaces`,
+        severity: "warning",
+    });
+}
+function addObjectTypeGroupsDiagnostic(objectType, objectIndex, apiName, diagnostics) {
+    if ((objectType.typeGroups?.length ?? 0) === 0) {
+        return;
+    }
+    diagnostics.push({
+        code: "partial.objectTypeGroups",
+        message: `Object ${apiName} references type groups; type-group membership is preserved only in summary output.`,
+        path: `$.objectTypes[${objectIndex}].typeGroups`,
+        severity: "info",
+    });
+}
+function resolveProperty(propertyId, propertiesById) {
+    return propertyId ? propertiesById.get(propertyId) : undefined;
+}
+function addKeyDiagnostics(objectType, objectIndex, apiName, primaryKeyProperty, titleProperty, diagnostics) {
+    addPrimaryKeyDiagnostics(objectType, objectIndex, apiName, primaryKeyProperty, diagnostics);
+    addTitlePropertyDiagnostics(objectIndex, apiName, titleProperty, diagnostics);
+}
+function addPrimaryKeyDiagnostics(objectType, objectIndex, apiName, primaryKeyProperty, diagnostics) {
+    addCompositePrimaryKeyDiagnostic(objectType, objectIndex, apiName, diagnostics);
+    addMissingPrimaryKeyDiagnostic(primaryKeyProperty, objectIndex, apiName, diagnostics);
+}
+function addCompositePrimaryKeyDiagnostic(objectType, objectIndex, apiName, diagnostics) {
+    if ((objectType.primaryKeys?.length ?? 0) === 1) {
+        return;
+    }
+    diagnostics.push({
+        code: "unsupported.compositePrimaryKey",
+        message: `Expected exactly one primary key for ${apiName}.`,
+        path: `$.objectTypes[${objectIndex}].primaryKeys`,
+        severity: "warning",
+    });
+}
+function addMissingPrimaryKeyDiagnostic(primaryKeyProperty, objectIndex, apiName, diagnostics) {
+    if (primaryKeyProperty) {
+        return;
+    }
+    diagnostics.push({
+        code: "missing.primaryKeyProperty",
+        message: `Primary key property could not be resolved for ${apiName}; using first property.`,
+        path: `$.objectTypes[${objectIndex}].primaryKeys`,
+        severity: "warning",
+    });
+}
+function addTitlePropertyDiagnostics(objectIndex, apiName, titleProperty, diagnostics) {
+    if (titleProperty) {
+        return;
+    }
+    diagnostics.push({
+        code: "missing.titleProperty",
+        message: `Title property could not be resolved for ${apiName}; using primary key or first property.`,
+        path: `$.objectTypes[${objectIndex}].titlePropertyId`,
+        severity: "warning",
+    });
+}

package/dist/foundry-import/parse.d.ts

@@ -0,0 +1,3 @@
+import type { ConversionDiagnostic, FoundryV2Export } from "./types.js";
+export declare function parseFoundryV2Export(input: unknown, diagnostics: ConversionDiagnostic[]): FoundryV2Export;
+//# sourceMappingURL=parse.d.ts.map

package/dist/foundry-import/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/foundry-import/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGxE,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,oBAAoB,EAAE,GACjC,eAAe,CAejB"}

package/dist/foundry-import/parse.js

@@ -0,0 +1,28 @@
+import { arrayField, isRecord } from "./utils.js";
+export function parseFoundryV2Export(input, diagnostics) {
+    if (!isRecord(input)) {
+        throw new Error("Expected a JSON object.");
+    }
+    const version = typeof input.version === "number" ? input.version : 0;
+    addVersionDiagnostic(version, input.version, diagnostics);
+    return {
+        actionTypes: arrayField(input, "actionTypes"),
+        interfaces: arrayField(input, "interfaces"),
+        objectTypes: arrayField(input, "objectTypes"),
+        relations: arrayField(input, "relations"),
+        sharedProperties: arrayField(input, "sharedProperties"),
+        typeGroups: arrayField(input, "typeGroups"),
+        version,
+    };
+}
+function addVersionDiagnostic(version, rawVersion, diagnostics) {
+    if (version === 2) {
+        return;
+    }
+    diagnostics.push({
+        code: "unsupported.version",
+        message: `Expected version 2 export, received ${String(rawVersion)}.`,
+        path: "$.version",
+        severity: "warning",
+    });
+}

package/dist/foundry-import/properties.d.ts

@@ -0,0 +1,4 @@
+import type { ConversionDiagnostic, FoundryProperty, FoundrySharedProperty, NormalizedProperty, NormalizedSharedProperty } from "./types.js";
+export declare function normalizeProperty(property: FoundryProperty, path: string, nameAllocator: (name: string) => string, diagnostics: ConversionDiagnostic[]): NormalizedProperty;
+export declare function normalizeSharedProperty(sharedProperty: FoundrySharedProperty, index: number, nameAllocator: (name: string) => string, variableNameAllocator: (name: string) => string, diagnostics: ConversionDiagnostic[]): NormalizedSharedProperty;
+//# sourceMappingURL=properties.d.ts.map

package/dist/foundry-import/properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties.d.ts","sourceRoot":"","sources":["../../src/foundry-import/properties.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACX,oBAAoB,EACpB,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,wBAAwB,EACxB,MAAM,YAAY,CAAC;AASpB,wBAAgB,iBAAiB,CAChC,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EACvC,WAAW,EAAE,oBAAoB,EAAE,GACjC,kBAAkB,CA0BpB;AAkED,wBAAgB,uBAAuB,CACtC,cAAc,EAAE,qBAAqB,EACrC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EACvC,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EAC/C,WAAW,EAAE,oBAAoB,EAAE,GACjC,wBAAwB,CA4C1B"}

package/dist/foundry-import/properties.js

@@ -0,0 +1,83 @@
+import { addSanitizationDiagnostic, sanitizeApiName } from "./names.js";
+import { mapPropertyType } from "./property-types.js";
+import { displayNameFor, normalizeDescription, normalizeNullability, requiredString, visibilityFor, } from "./utils.js";
+export function normalizeProperty(property, path, nameAllocator, diagnostics) {
+    const apiName = normalizePropertyApiName(property, path, nameAllocator, diagnostics);
+    addValueTypeDiagnostic(property, apiName.original, path, diagnostics);
+    const mappedType = mapPropertyType(property.baseType, `${path}.baseType`, diagnostics);
+    return {
+        apiName,
+        array: mappedType.array,
+        description: propertyDescription(property),
+        displayName: propertyDisplayName(property, apiName.sanitized),
+        editOnly: isEditOnlyProperty(property),
+        indexedForSearch: propertyIndexedForSearch(property),
+        nullability: propertyNullability(property, path, diagnostics),
+        originalId: propertyOriginalId(property, apiName.original),
+        rid: property.rid,
+        type: mappedType.type,
+        visibility: propertyVisibility(property),
+    };
+}
+function propertyDescription(property) {
+    return normalizeDescription(property.displayMetadata?.description);
+}
+function propertyDisplayName(property, fallback) {
+    return displayNameFor(property.displayMetadata, fallback);
+}
+function isEditOnlyProperty(property) {
+    return property.source?.type === "editOnly";
+}
+function propertyIndexedForSearch(property) {
+    return property.indexedForSearch ?? false;
+}
+function propertyOriginalId(property, fallback) {
+    return property.id ?? fallback;
+}
+function propertyNullability(property, path, diagnostics) {
+    return normalizeNullability(property.dataConstraints?.nullability, `${path}.dataConstraints.nullability`, diagnostics);
+}
+function propertyVisibility(property) {
+    return visibilityFor(property.displayMetadata);
+}
+function normalizePropertyApiName(property, path, nameAllocator, diagnostics) {
+    const original = requiredString(property.apiName, `${path}.apiName`, diagnostics, property.id ?? "property");
+    const sanitized = nameAllocator(sanitizeApiName(original, "api"));
+    addSanitizationDiagnostic(diagnostics, `${path}.apiName`, original, sanitized);
+    return { original, sanitized };
+}
+export function normalizeSharedProperty(sharedProperty, index, nameAllocator, variableNameAllocator, diagnostics) {
+    const path = `$.sharedProperties[${index}]`;
+    const originalApiName = requiredString(sharedProperty.apiName, `${path}.apiName`, diagnostics, `SharedProperty${index + 1}`);
+    const sanitizedApiName = nameAllocator(sanitizeApiName(originalApiName, "api"));
+    addSanitizationDiagnostic(diagnostics, `${path}.apiName`, originalApiName, sanitizedApiName);
+    const mappedType = mapPropertyType(sharedProperty.baseType, `${path}.baseType`, diagnostics);
+    return {
+        apiName: { original: originalApiName, sanitized: sanitizedApiName },
+        array: mappedType.array,
+        description: normalizeDescription(sharedProperty.displayMetadata?.description),
+        displayName: displayNameFor(sharedProperty.displayMetadata, sanitizedApiName),
+        nullability: normalizeNullability(sharedProperty.dataConstraints?.nullability, `${path}.dataConstraints.nullability`, diagnostics),
+        rid: sharedProperty.rid,
+        type: mappedType.type,
+        variableName: variableNameAllocator(`${toPascalCaseLocal(sanitizedApiName)}Spt`),
+        visibility: visibilityFor(sharedProperty.displayMetadata),
+    };
+}
+function addValueTypeDiagnostic(property, apiName, path, diagnostics) {
+    if (!property.valueType) {
+        return;
+    }
+    diagnostics.push({
+        code: "partial.valueTypeReference",
+        message: `Property ${apiName} references a Foundry value type; preserving scalar type only in OAC output.`,
+        path: `${path}.valueType`,
+        severity: "info",
+    });
+}
+function toPascalCaseLocal(value) {
+    const words = value.match(/[a-zA-Z0-9]+/g) ?? ["Imported"];
+    return words
+        .map((word) => `${word[0]?.toUpperCase() ?? ""}${word.slice(1)}`)
+        .join("");
+}

package/dist/foundry-import/property-types.d.ts

@@ -0,0 +1,7 @@
+import type { ConversionDiagnostic, FoundryBaseType } from "./types.js";
+export interface MappedPropertyType {
+    readonly array: boolean;
+    readonly type: unknown;
+}
+export declare function mapPropertyType(baseType: FoundryBaseType | undefined, path: string, diagnostics: ConversionDiagnostic[]): MappedPropertyType;
+//# sourceMappingURL=property-types.d.ts.map

package/dist/foundry-import/property-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"property-types.d.ts","sourceRoot":"","sources":["../../src/foundry-import/property-types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,oBAAoB,EACpB,eAAe,EAEf,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACvB;AA0BD,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,eAAe,GAAG,SAAS,EACrC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,oBAAoB,EAAE,GACjC,kBAAkB,CAEpB"}

package/dist/foundry-import/property-types.js

@@ -0,0 +1,77 @@
+import { sanitizeApiName } from "./names.js";
+const typeHandlers = {
+    ARRAY: mapArrayType,
+    ATTACHMENT: scalarType("attachment"),
+    BOOLEAN: scalarType("boolean"),
+    DATE: scalarType("date"),
+    DOUBLE: scalarType("double"),
+    GEOHASH: scalarType("geopoint"),
+    GEOSHAPE: scalarType("geoshape"),
+    INTEGER: scalarType("integer"),
+    LONG: scalarType("long"),
+    MARKING: mapMarkingType,
+    MEDIA_REFERENCE: scalarType("mediaReference"),
+    STRING: scalarType("string"),
+    STRUCT: mapStructType,
+    TIMESTAMP: scalarType("timestamp"),
+    VECTOR: mapVectorType,
+};
+export function mapPropertyType(baseType, path, diagnostics) {
+    return typeHandlerFor(baseType)(baseType, path, diagnostics);
+}
+function typeHandlerFor(baseType) {
+    return typeHandlers[baseType?.type ?? ""] ?? coerceUnknownType;
+}
+function scalarType(type) {
+    return () => ({ array: false, type });
+}
+function mapArrayType(baseType, path, diagnostics) {
+    return {
+        array: true,
+        type: mapPropertyType(baseType?.subType, `${path}.subType`, diagnostics)
+            .type,
+    };
+}
+function mapMarkingType(baseType) {
+    return {
+        array: false,
+        type: {
+            markingInputGroupName: "ImportedMarkings",
+            markingType: baseType?.markingType ?? "MANDATORY",
+            type: "marking",
+        },
+    };
+}
+function mapStructType(baseType, path, diagnostics) {
+    return {
+        array: false,
+        type: {
+            structDefinition: Object.fromEntries((baseType?.structFields ?? []).map((field, index) => structFieldEntry(field, `${path}.structFields[${index}]`, diagnostics))),
+            type: "struct",
+        },
+    };
+}
+function structFieldEntry(field, path, diagnostics) {
+    return [
+        sanitizeApiName(field.apiName ?? "field", "api"),
+        mapPropertyType(field.fieldType, `${path}.fieldType`, diagnostics).type,
+    ];
+}
+function mapVectorType(_baseType, path, diagnostics) {
+    diagnostics.push({
+        code: "coerced.vectorType",
+        message: "Vector properties are emitted as strings in the first-pass OAC output.",
+        path,
+        severity: "warning",
+    });
+    return { array: false, type: "string" };
+}
+function coerceUnknownType(baseType, path, diagnostics) {
+    diagnostics.push({
+        code: "coerced.unknownPropertyType",
+        message: `Unknown property type ${String(baseType?.type)} emitted as string.`,
+        path,
+        severity: "warning",
+    });
+    return { array: false, type: "string" };
+}

package/dist/foundry-import/relations.d.ts

@@ -0,0 +1,11 @@
+import type { ConversionDiagnostic, FoundryRelation, NormalizedObject, NormalizedRelation } from "./types.js";
+export declare function normalizeRelation(relation: FoundryRelation, relationIndex: number, objectsByRid: ReadonlyMap<string, NormalizedObject>, relationNameAllocator: (name: string) => string, variableNameAllocator: (name: string) => string, diagnostics: ConversionDiagnostic[]): readonly NormalizedRelation[];
+export declare function raw(value: string): {
+    readonly __raw: true;
+    readonly value: string;
+};
+export declare function isRaw(value: unknown): value is {
+    readonly __raw: true;
+    readonly value: string;
+};
+//# sourceMappingURL=relations.d.ts.map

package/dist/foundry-import/relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../src/foundry-import/relations.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACX,oBAAoB,EAIpB,eAAe,EACf,gBAAgB,EAEhB,kBAAkB,EAClB,MAAM,YAAY,CAAC;AA4BpB,wBAAgB,iBAAiB,CAChC,QAAQ,EAAE,eAAe,EACzB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACnD,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EAC/C,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EAC/C,WAAW,EAAE,oBAAoB,EAAE,GACjC,SAAS,kBAAkB,EAAE,CAO/B;AA8UD,wBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG;IACnC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB,CAEA;AAED,wBAAgB,KAAK,CACpB,KAAK,EAAE,OAAO,GACZ,KAAK,IAAI;IAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAI3D"}

package/dist/foundry-import/relations.js

@@ -0,0 +1,204 @@
+import { addSanitizationDiagnostic, sanitizeApiName, toPascalCase, } from "./names.js";
+import { isRecord, normalizeStatus, visibilityFor } from "./utils.js";
+const relationNormalizers = {
+    intermediary: skipIntermediaryRelation,
+    manyToMany: normalizeRelationWithManyToMany,
+    oneToMany: normalizeRelationWithOneToMany,
+};
+export function normalizeRelation(relation, relationIndex, objectsByRid, relationNameAllocator, variableNameAllocator, diagnostics) {
+    return relationNormalizerFor(relation)(relation, relationIndex, {
+        diagnostics,
+        objectsByRid,
+        relationNameAllocator,
+        variableNameAllocator,
+    });
+}
+function relationNormalizerFor(relation) {
+    return (relationNormalizers[relationDefinitionType(relation) ?? ""] ??
+        skipUnknownRelation);
+}
+function relationDefinitionType(relation) {
+    return relation.definition?.type;
+}
+function linkMetadata(metadata) {
+    const displayMetadata = linkDisplayMetadata(metadata);
+    return {
+        apiName: sanitizeApiName(linkApiName(metadata), "api"),
+        displayName: linkDisplayName(metadata, displayMetadata),
+        groupDisplayName: displayMetadataValue(displayMetadata, "groupDisplayName"),
+        pluralDisplayName: displayMetadataValue(displayMetadata, "pluralDisplayName"),
+        visibility: visibilityFor(displayMetadata),
+    };
+}
+function linkDisplayMetadata(metadata) {
+    return metadata?.displayMetadata;
+}
+function linkApiName(metadata) {
+    return metadata?.apiName ?? "link";
+}
+function linkDisplayName(metadata, displayMetadata) {
+    return firstPresent(displayMetadata?.displayName, metadata?.apiName, "Link");
+}
+function firstPresent(...values) {
+    return (values.find((value) => typeof value === "string" && value !== "") ?? "Link");
+}
+function displayMetadataValue(displayMetadata, key) {
+    return displayMetadata?.[key] ?? undefined;
+}
+function normalizeRelationWithOneToMany(relation, relationIndex, context) {
+    const oneToMany = relation.definition?.oneToMany;
+    if (!oneToMany) {
+        return skipMalformedRelation(relation, relationIndex, context.diagnostics);
+    }
+    return normalizeOneToManyRelation(relation, oneToMany, relationIndex, context);
+}
+function normalizeRelationWithManyToMany(relation, relationIndex, context) {
+    const manyToMany = relation.definition?.manyToMany;
+    if (!manyToMany) {
+        return skipMalformedRelation(relation, relationIndex, context.diagnostics);
+    }
+    return normalizeManyToManyRelation(relation, manyToMany, relationIndex, context);
+}
+function normalizeOneToManyRelation(relation, oneToMany, relationIndex, context) {
+    const requirements = resolveOneToManyRequirements(relation, oneToMany, relationIndex, context);
+    if (!requirements) {
+        return [];
+    }
+    const relationNames = allocateRelationNames(relation, relationIndex, context.relationNameAllocator, context.variableNameAllocator, context.diagnostics);
+    return [
+        {
+            apiName: relationNames.apiName,
+            definition: {
+                apiName: relationNames.apiName.sanitized,
+                cardinality: cardinalityFor(oneToMany),
+                manyForeignKeyProperty: requirements.manyForeignKeyProperty.apiName.sanitized,
+                one: {
+                    metadata: linkMetadata(oneToMany.oneToManyLinkMetadata),
+                    object: raw(requirements.one.variableName),
+                },
+                toMany: {
+                    metadata: linkMetadata(oneToMany.manyToOneLinkMetadata),
+                    object: raw(requirements.many.variableName),
+                },
+            },
+            kind: "oneToMany",
+            rid: relation.rid,
+            status: normalizeStatus(relation.status),
+            variableName: relationNames.variableName,
+        },
+    ];
+}
+function resolveOneToManyRequirements(relation, oneToMany, relationIndex, context) {
+    const one = objectByRid(oneToMany.objectTypeRidOneSide, context.objectsByRid);
+    const many = objectByRid(oneToMany.objectTypeRidManySide, context.objectsByRid);
+    if (!one || !many) {
+        addRelationObjectReferenceDiagnostic(relation, relationIndex, context.diagnostics);
+        return undefined;
+    }
+    const manyForeignKeyProperty = propertyById(oneToMany.manySideForeignKeyPropertyId, many.propertiesById);
+    if (!manyForeignKeyProperty) {
+        addRelationForeignKeyDiagnostic(relation, relationIndex, context.diagnostics);
+        return undefined;
+    }
+    return { many, manyForeignKeyProperty, one };
+}
+function cardinalityFor(oneToMany) {
+    return oneToMany.cardinalityHint === "ONE_TO_ONE" ? "OneToOne" : "OneToMany";
+}
+function normalizeManyToManyRelation(relation, manyToMany, relationIndex, context) {
+    const objectA = objectByRid(manyToMany.objectTypeRidA, context.objectsByRid);
+    const objectB = objectByRid(manyToMany.objectTypeRidB, context.objectsByRid);
+    if (!objectA || !objectB) {
+        addRelationObjectReferenceDiagnostic(relation, relationIndex, context.diagnostics);
+        return [];
+    }
+    const relationNames = allocateRelationNames(relation, relationIndex, context.relationNameAllocator, context.variableNameAllocator, context.diagnostics);
+    return [
+        {
+            apiName: relationNames.apiName,
+            definition: {
+                apiName: relationNames.apiName.sanitized,
+                many: {
+                    metadata: linkMetadata(manyToMany.objectTypeAToBLinkMetadata),
+                    object: raw(objectA.variableName),
+                },
+                toMany: {
+                    metadata: linkMetadata(manyToMany.objectTypeBToALinkMetadata),
+                    object: raw(objectB.variableName),
+                },
+            },
+            kind: "manyToMany",
+            rid: relation.rid,
+            status: normalizeStatus(relation.status),
+            variableName: relationNames.variableName,
+        },
+    ];
+}
+function skipIntermediaryRelation(relation, relationIndex, context) {
+    context.diagnostics.push({
+        code: "skipped.intermediaryRelation",
+        message: `Intermediary relation ${relationLabel(relation, relationIndex)} is preserved only in diagnostics for this first pass.`,
+        path: `$.relations[${relationIndex}]`,
+        severity: "warning",
+    });
+    return [];
+}
+function skipUnknownRelation(relation, relationIndex, context) {
+    const definitionType = relationDefinitionType(relation);
+    context.diagnostics.push({
+        code: "skipped.unknownRelation",
+        message: `Relation ${relationLabel(relation, relationIndex)} has unsupported definition type ${String(definitionType)}.`,
+        path: `$.relations[${relationIndex}].definition.type`,
+        severity: "warning",
+    });
+    return [];
+}
+function skipMalformedRelation(relation, relationIndex, diagnostics) {
+    diagnostics.push({
+        code: "skipped.malformedRelation",
+        message: `Relation ${relationLabel(relation, relationIndex)} is missing the expected relation definition body.`,
+        path: `$.relations[${relationIndex}].definition`,
+        severity: "warning",
+    });
+    return [];
+}
+function allocateRelationNames(relation, relationIndex, relationNameAllocator, variableNameAllocator, diagnostics) {
+    const original = relation.id ?? `relation${relationIndex}`;
+    const sanitized = relationNameAllocator(sanitizeApiName(original, "api"));
+    addSanitizationDiagnostic(diagnostics, `$.relations[${relationIndex}].id`, original, sanitized);
+    return {
+        apiName: { original, sanitized },
+        variableName: variableNameAllocator(`${toPascalCase(sanitized)}Link`),
+    };
+}
+function objectByRid(rid, objectsByRid) {
+    return rid ? objectsByRid.get(rid) : undefined;
+}
+function propertyById(propertyId, propertiesById) {
+    return propertyId ? propertiesById.get(propertyId) : undefined;
+}
+function addRelationObjectReferenceDiagnostic(relation, relationIndex, diagnostics) {
+    diagnostics.push({
+        code: "skipped.relationObjectReference",
+        message: `Relation ${relationLabel(relation, relationIndex)} references an unknown object.`,
+        path: `$.relations[${relationIndex}]`,
+        severity: "warning",
+    });
+}
+function addRelationForeignKeyDiagnostic(relation, relationIndex, diagnostics) {
+    diagnostics.push({
+        code: "skipped.relationForeignKey",
+        message: `Relation ${relationLabel(relation, relationIndex)} has no resolvable many-side foreign key.`,
+        path: `$.relations[${relationIndex}].definition.oneToMany.manySideForeignKeyPropertyId`,
+        severity: "warning",
+    });
+}
+function relationLabel(relation, relationIndex) {
+    return relation.id ?? relation.rid ?? String(relationIndex);
+}
+export function raw(value) {
+    return { __raw: true, value };
+}
+export function isRaw(value) {
+    return (isRecord(value) && value.__raw === true && typeof value.value === "string");
+}