swoop-common 1.0.35 → 1.0.37

package/dist/api/additions/templateHierarchyResolver.d.ts

@@ -0,0 +1,2 @@
+import { DTOTemplateRead } from "../generated/core";
+export declare const resolveTemplateHierarchy: (templateId: string) => Promise<DTOTemplateRead[]>;

package/dist/api/additions/templateHierarchyResolver.js

@@ -0,0 +1,102 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { services } from "../init";
+const buildTemplateTree = (templates) => {
+    const revisionGroups = new Map();
+    // Step 1: Group templates by revisionGroupId
+    for (const template of templates) {
+        const groupId = template.revisionGroupId;
+        if (!revisionGroups.has(groupId)) {
+            revisionGroups.set(groupId, {
+                revisionGroupId: groupId,
+                versions: [],
+                children: [],
+                parentRevisionGroupId: null,
+            });
+        }
+        revisionGroups.get(groupId).versions.push(template);
+    }
+    // Step 2: Assign parentRevisionGroupId from the latest template in each group
+    for (const group of revisionGroups.values()) {
+        const latest = group.versions.reduce((a, b) => a.revision > b.revision ? a : b);
+        group.parentRevisionGroupId = latest.parentRevisionGroupId || null;
+    }
+    // Step 3: Build hierarchy
+    const roots = [];
+    for (const group of revisionGroups.values()) {
+        const parentId = group.parentRevisionGroupId;
+        if (parentId && revisionGroups.has(parentId)) {
+            revisionGroups.get(parentId).children.push(group);
+        }
+        else {
+            roots.push(group);
+        }
+    }
+    return roots;
+};
+export const resolveTemplateHierarchy = (templateId) => __awaiter(void 0, void 0, void 0, function* () {
+    // First fetch all templates
+    const allTemplates = yield services.CoreService.templateList(1);
+    console.log(JSON.stringify(allTemplates, null, 2));
+    // Find the initial template
+    const initialTemplate = allTemplates.data.find((t) => t.id === templateId);
+    if (!initialTemplate) {
+        throw new Error(`Template with ID ${templateId} not found`);
+    }
+    // Build the complete template tree
+    const templateTree = buildTemplateTree(allTemplates.data);
+    // Find the group containing our template
+    const findGroup = (groups) => {
+        for (const group of groups) {
+            if (group.versions.some((t) => t.id === templateId)) {
+                return group;
+            }
+            const found = findGroup(group.children);
+            if (found)
+                return found;
+        }
+        return undefined;
+    };
+    const targetGroup = findGroup(templateTree);
+    if (!targetGroup) {
+        throw new Error(`Could not find template group for template ${templateId}`);
+    }
+    // Build the hierarchy by following parent links
+    const hierarchy = [];
+    let currentGroup = targetGroup;
+    while (currentGroup) {
+        // Get the latest version of the current group
+        const latestTemplate = currentGroup.versions.reduce((a, b) => a.revision > b.revision ? a : b);
+        hierarchy.unshift(latestTemplate); // Add to beginning to get root -> leaf order
+        // Move up to parent group
+        if (currentGroup.parentRevisionGroupId) {
+            // Find the parent group in the tree
+            const findParentGroup = (groups) => {
+                for (const group of groups) {
+                    if (group.revisionGroupId === currentGroup.parentRevisionGroupId) {
+                        return group;
+                    }
+                    const found = findParentGroup(group.children);
+                    if (found)
+                        return found;
+                }
+                return undefined;
+            };
+            const parentGroup = findParentGroup(templateTree);
+            if (!parentGroup)
+                break;
+            currentGroup = parentGroup;
+        }
+        else {
+            break;
+        }
+    }
+    return hierarchy; // Already in root -> leaf order
+});

package/dist/api/generated/itinerary/services/ItineraryService.d.ts

@@ -4,7 +4,8 @@ import type { DTOItineraryUpdate } from '../models/DTOItineraryUpdate';
 import type { DTORegionCreate } from '../models/DTORegionCreate';
 import type { DTORegionRead } from '../models/DTORegionRead';
 import type { Pagination } from '../models/Pagination';
-import type { CancelablePromise } from '../core/CancelablePromise';
+import { CancelablePromise } from '../core/CancelablePromise';
+import { DTOTemplateRead } from '../models/DTOTemplateRead';
 export declare class ItineraryService {
     /**
      * List Itineraries
@@ -82,4 +83,10 @@ export declare class ItineraryService {
      * @throws ApiError
      */
     regionCreate(requestBody?: DTORegionCreate): CancelablePromise<DTORegionRead>;
+    /**
+     * Resolve template hierarchy
+     * @returns Array<DTOTemplateRead> OK
+     * @throws Error | ApiError
+     */
+    templateResolveHierarchy(templateId: string): CancelablePromise<Array<DTOTemplateRead>>;
 }

package/dist/api/generated/itinerary/services/ItineraryService.js

@@ -1,5 +1,16 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
+import { resolveTemplateHierarchy } from '../../../additions/templateHierarchyResolver';
 export class ItineraryService {
     /**
      * List Itineraries
@@ -140,4 +151,15 @@ export class ItineraryService {
             mediaType: 'application/json',
         });
     }
+    /**
+     * Resolve template hierarchy
+     * @returns Array<DTOTemplateRead> OK
+     * @throws Error | ApiError
+     */
+    templateResolveHierarchy(templateId) {
+        return new CancelablePromise((resolve, _reject, _onCancel) => __awaiter(this, void 0, void 0, function* () {
+            const out = yield resolveTemplateHierarchy(templateId);
+            resolve(out);
+        }));
+    }
 }

package/dist/api/init.d.ts

@@ -1,6 +1,11 @@
 import * as Core from "./generated/core/index";
 import * as Itinerary from "./generated/itinerary/index";
 import * as Swoop from "./generated/swoop/index";
+export declare const services: {
+    SwoopService: Swoop.SwoopService;
+    CoreService: Core.CoreService;
+    ItineraryService: Itinerary.ItineraryService;
+};
 export declare const init: (opts: {
     itineraryServiceUrl: string;
     coreServiceUrl: string;

package/dist/api/init.js

@@ -2,6 +2,11 @@ import * as Core from "./generated/core/index";
 import * as Itinerary from "./generated/itinerary/index";
 import * as Swoop from "./generated/swoop/index";
 let initalised = false;
+export const services = {
+    SwoopService: new Swoop.SwoopService(),
+    CoreService: new Core.CoreService(),
+    ItineraryService: new Itinerary.ItineraryService(),
+};
 export const init = (opts) => {
     // Keeps it consitent
     if (opts.coreServiceUrl.endsWith("/"))
@@ -15,11 +20,7 @@ export const init = (opts) => {
     Itinerary.OpenAPI.BASE = opts.itineraryServiceUrl;
     Swoop.OpenAPI.BASE = opts.swoopServiceForwardUrl;
     initalised = true;
-    return {
-        SwoopService: new Swoop.SwoopService(),
-        CoreService: new Core.CoreService(),
-        ItineraryService: new Itinerary.ItineraryService(),
-    };
+    return services;
 };
 export const initialisedCheck = () => {
     if (initalised)

package/dist/rendering/components/StyledFormView.d.ts

@@ -30,8 +30,10 @@ interface Props {
      * The stage at which to render this template
      */
     stage: Stage;
-    jsonSchema?: any;
-    uiSchema?: any;
+    /**
+     * Should readonly fields be hidden
+     */
+    hideReadonlyFields?: boolean;
 }
 export declare const StyledFormView: React.FC<Props>;
 export {};

package/dist/rendering/components/StyledFormView.js

@@ -5,9 +5,9 @@ import { getComponents } from '../registry/components';
 import { generateJsonSchema } from '../schema/generate/jsonSchemaGenerate';
 import { generateUiSchema } from '../schema/generate/uiSchemaGenerate';
 import { initialisedCheck } from '../../api/init';
-export const StyledFormView = ({ initialData, schema, onChange, stage, pool, readonly, jsonSchema, uiSchema }) => {
+export const StyledFormView = ({ initialData, schema, onChange, stage, pool, readonly, hideReadonlyFields }) => {
     useEffect(initialisedCheck, []);
-    const json = jsonSchema || generateJsonSchema(schema, stage);
-    const ui = uiSchema || generateUiSchema(schema, stage);
+    const json = generateJsonSchema(schema, stage, hideReadonlyFields);
+    const ui = generateUiSchema(schema, stage, hideReadonlyFields);
     return (React.createElement(JsonForms, { onChange: onChange, data: initialData, schema: json, uischema: ui, renderers: [...materialRenderers, ...getComponents(pool)], readonly: readonly, cells: materialCells }));
 };

package/dist/rendering/renderers/ComponentPicker.js

@@ -12,7 +12,7 @@ import { Paper, Typography, Box, TextField, Autocomplete } from '@mui/material';
 import { useLocalErrors } from '../hooks/errors';
 import { ComponentPool } from '../registry/types';
 import { registerComponent } from '../registry/components';
-import { CoreService } from '../util/lib';
+import { services } from '../../api/init';
 const FormComponentPicker = ({ components, selectedComponent, onChange, templateIds, getError, label, enabled }) => {
     const selected = components.find(c => c.id === selectedComponent) || null;
     return (React.createElement(Paper, { component: "form", sx: { display: 'flex', flexDirection: 'column', gap: 1, p: 2, mb: 1 }, noValidate: true, autoComplete: "off" },
@@ -51,7 +51,7 @@ const FormRendererComponentPicker = ({ data, handleChange, path, label, enabled,
 registerComponent("component", FormRendererComponentPicker, ComponentPool.FORM);
 export const fetchComponents = () => __awaiter(void 0, void 0, void 0, function* () {
     const componentsByGroup = new Map();
-    const data = yield CoreService.componentList(1, 1000);
+    const data = yield services.CoreService.componentList(1, 1000);
     (data.data || []).forEach((component) => {
         const groupId = component.revisionGroupId;
         if (!componentsByGroup.has(groupId)) {

package/dist/rendering/renderers/TemplatePicker.js

@@ -13,7 +13,7 @@ import { Paper, Typography, Box, TextField, Chip, Autocomplete } from '@mui/mate
 import { useLocalErrors } from '../hooks/errors';
 import { registerComponent } from '../registry/components';
 import { ComponentPool } from '../registry/types';
-import { CoreService } from '../util/lib';
+import { services } from '../../api/init';
 const FormTemplatePicker = ({ templates, selectedTemplates, onChange, label, enabled }) => {
     const selectedValues = templates.filter(t => selectedTemplates.includes(t.id));
     return (React.createElement(Paper, { component: "form", sx: { display: 'flex', flexDirection: 'column', gap: 2, p: 2, mb: 1 }, noValidate: true, autoComplete: "off" },
@@ -33,7 +33,7 @@ const FormRendererTemplatePicker = ({ data, handleChange, path, label, enabled }
     useEffect(() => {
         const load = () => __awaiter(void 0, void 0, void 0, function* () {
             try {
-                const result = yield CoreService.templateList(1);
+                const result = yield services.CoreService.templateList(1);
                 setTemplates(result.data);
             }
             catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "swoop-common",
-    "version": "1.0.35",
+    "version": "1.0.37",
     "main": "dist/api/index.js",
     "types": "dist/api/index.d.ts",
     "exports": {

package/dist/rendering/util/lib.d.ts

@@ -1 +0,0 @@
-export declare const SwoopService: import("../../api/generated/swoop").SwoopService, ItineraryService: import("../../api/generated/itinerary").ItineraryService, CoreService: import("../../api/generated/core").CoreService;

package/dist/rendering/util/lib.js

@@ -1,6 +0,0 @@
-import { init } from "../../api/init";
-export const { SwoopService, ItineraryService, CoreService } = init({
-    coreServiceUrl: "https://data-api-dev.swoop-adventures.com/core-data-service/v1/",
-    itineraryServiceUrl: "https://data-api-dev.swoop-adventures.com/itinerary-builder-service/v1/",
-    swoopServiceForwardUrl: "https://data-api-dev.swoop-adventures.com/itinerary-builder-service/v1/forward"
-});