@cybertale/resolver 0.1.2 → 1.0.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@cybertale/resolver",
-  "version": "0.1.2",
+  "version": "1.0.0",
   "type": "module",
-  "main": "dist/index.cjs",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "main": "src/index.ts",
+  "module": "src/index.ts",
+  "types": "src/index.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/Joso997/cybertale-resolver.git"
@@ -13,7 +13,16 @@
   "bugs": {
     "url": "https://github.com/Joso997/cybertale-resolver/issues"
   },
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "require": "./src/index.ts"
+    }
+  },
   "peerDependencies": {
     "@cybertale/interface": "*"
+  },
+  "dependencies": {
+    "uuid": "^10.0.0"
   }
 }

package/src/index.ts

@@ -23,3 +23,11 @@ export * as FinalizeDefaults from './resolver/finalize/defaults'
 export * as HandlersRemove from './resolver/handlers/remove'
 export * as HandlersInsert from './resolver/handlers/insert'
 export * as HandlersUpdate from './resolver/handlers/update'
+export * as HandlersTemplate from './resolver/handlers/template'
+
+// assignments
+export { WrapperAbstract } from './resolver/assignments/wrapperAbstract'
+export { FormWrapper } from './resolver/assignments/formWrapper'
+export { RowWrapper } from './resolver/assignments/rowWrapper'
+export { TableWrapper } from './resolver/assignments/tableWrapper'
+export type { ResolverInterface } from './resolver/assignments/resolverInterface'

package/src/resolver/assignments/formWrapper.ts

@@ -0,0 +1,84 @@
+import type { EventHandlerType, ObjectTemplate } from '@cybertale/interface'
+import { WrapperAbstract } from './wrapperAbstract'
+
+export class FormWrapper extends WrapperAbstract {
+  Button (
+    eventHandler: EventHandlerType,
+    objectTemplates: ObjectTemplate[],
+    refreshPage: () => void,
+    append: (_objectTemplates: ObjectTemplate[]) => ObjectTemplate[],
+    id: string,
+    inEdit: boolean,
+    version: string,
+  ): FormWrapper {
+    this.eventHandler = eventHandler
+    this.objectTemplates = objectTemplates
+    this.refreshPage = refreshPage
+    this.append = append
+    this.id = id
+    this.inEdit = inEdit
+    this.version = version
+    return this
+  }
+
+  DataList (
+    eventHandler: EventHandlerType,
+    objectTemplates: ObjectTemplate[],
+    refreshPage: () => void,
+  ): FormWrapper {
+    this.eventHandler = eventHandler
+    this.objectTemplates = objectTemplates
+    this.refreshPage = refreshPage
+    return this
+  }
+
+  ModalList (
+    eventHandler: EventHandlerType,
+    objectTemplates: ObjectTemplate[],
+    refreshPage: () => void,
+  ): FormWrapper {
+    this.eventHandler = eventHandler
+    this.objectTemplates = objectTemplates
+    this.refreshPage = refreshPage
+    return this
+  }
+
+  SelectList (
+    eventHandler: EventHandlerType,
+    objectTemplates: ObjectTemplate[],
+    refreshPage: () => void,
+    append: (_objectTemplates: ObjectTemplate[]) => ObjectTemplate[],
+  ): FormWrapper {
+    this.eventHandler = eventHandler
+    this.objectTemplates = objectTemplates
+    this.refreshPage = refreshPage
+    this.append = append
+    return this
+  }
+
+  Field (
+    eventHandler: EventHandlerType,
+    objectTemplates: ObjectTemplate[],
+    refreshPage: () => void,
+    append: (_objectTemplates: ObjectTemplate[]) => ObjectTemplate[],
+  ): FormWrapper {
+    this.eventHandler = eventHandler
+    this.objectTemplates = objectTemplates
+    this.refreshPage = refreshPage
+    this.append = append
+    return this
+  }
+
+  Radio (
+    eventHandler: EventHandlerType,
+    objectTemplates: ObjectTemplate[],
+    refreshPage: () => void,
+    append: (_objectTemplates: ObjectTemplate[]) => ObjectTemplate[],
+  ): FormWrapper {
+    this.eventHandler = eventHandler
+    this.objectTemplates = objectTemplates
+    this.refreshPage = refreshPage
+    this.append = append
+    return this
+  }
+}

package/src/resolver/assignments/resolverInterface.ts

@@ -0,0 +1,12 @@
+import type { ObjectTemplate } from '@cybertale/interface'
+
+export interface ResolverInterface<T> {
+  FormSelectList (wrapper: T): Promise<ObjectTemplate[]>
+  FormModalDataList (wrapper: T): Promise<ObjectTemplate[]>
+  FormDataList (wrapper: T): Promise<ObjectTemplate[]>
+  FormButton (wrapper: T): Promise<ObjectTemplate[]>
+  FormRadio (wrapper: T): Promise<ObjectTemplate[]>
+  FormField (wrapper: T): Promise<ObjectTemplate[]>
+  RowButton (wrapper: T): Promise<ObjectTemplate[]>
+  TableButton (wrapper: T): Promise<ObjectTemplate[]>
+}

package/src/resolver/assignments/rowWrapper.ts

@@ -0,0 +1,19 @@
+import type { EventHandlerType, ObjectTemplate } from '@cybertale/interface'
+import { WrapperAbstract } from './wrapperAbstract'
+
+export class RowWrapper extends WrapperAbstract {
+  public Button (
+    eventHandler: EventHandlerType,
+    objectTemplates: ObjectTemplate[],
+    refreshPage: () => void,
+    id: string,
+    version: string,
+  ): RowWrapper {
+    this.eventHandler = eventHandler
+    this.objectTemplates = objectTemplates
+    this.refreshPage = refreshPage
+    this.id = id
+    this.version = version
+    return this
+  }
+}

package/src/resolver/assignments/tableWrapper.ts

@@ -0,0 +1,15 @@
+import type { EventHandlerType, ObjectTemplate } from '@cybertale/interface'
+import { WrapperAbstract } from './wrapperAbstract'
+
+export class TableWrapper extends WrapperAbstract {
+  public Button (
+    eventHandler: EventHandlerType,
+    objectTemplates: ObjectTemplate[],
+    refreshPage: () => void,
+  ): TableWrapper {
+    this.eventHandler = eventHandler
+    this.objectTemplates = objectTemplates
+    this.refreshPage = refreshPage
+    return this
+  }
+}

package/src/resolver/assignments/wrapperAbstract.ts

@@ -0,0 +1,67 @@
+import type { EventHandlerType, ObjectTemplate } from '@cybertale/interface'
+
+export class WrapperAbstract {
+  get inEdit (): boolean {
+    return <boolean> this._inEdit
+  }
+
+  set inEdit (value: boolean) {
+    this._inEdit = value
+  }
+
+  get id (): string {
+    return <string> this._id
+  }
+
+  set id (value: string) {
+    this._id = value
+  }
+
+  get version (): string {
+    return <string> this._version
+  }
+
+  set version (value: string) {
+    this._version = value
+  }
+
+  get append (): (_objectTemplates: ObjectTemplate[]) => ObjectTemplate[] {
+    return <(_objectTemplates: ObjectTemplate[]) => ObjectTemplate[]> this._append
+  }
+
+  set append (value: (_objectTemplates: ObjectTemplate[]) => ObjectTemplate[]) {
+    this._append = value
+  }
+
+  get refreshPage (): () => void {
+    return <() => void> this._refreshPage
+  }
+
+  set refreshPage (value: () => void) {
+    this._refreshPage = value
+  }
+
+  get objectTemplates (): ObjectTemplate[] {
+    return <ObjectTemplate[]> this._objectTemplates
+  }
+
+  set objectTemplates (value: ObjectTemplate[]) {
+    this._objectTemplates = value
+  }
+
+  get eventHandler (): EventHandlerType {
+    return <EventHandlerType> this._eventHandler
+  }
+
+  set eventHandler (value: EventHandlerType) {
+    this._eventHandler = value
+  }
+
+  private _eventHandler: EventHandlerType | undefined
+  private _objectTemplates: ObjectTemplate[] | undefined
+  private _refreshPage: (() => void) | undefined
+  private _append: ((_objectTemplates: ObjectTemplate[]) => ObjectTemplate[]) | undefined
+  private _id: string | undefined
+  private _inEdit: boolean | undefined
+  private _version: string | undefined
+}

package/src/resolver/form/value.ts

@@ -1,7 +1,5 @@
 import type { ObjectTemplate } from '@cybertale/interface'
-import { StatTypeEnum } from '@cybertale/interface'
-import { getStringStat, hasStat } from '../transform/stat'
-import { isJSONArray, parseJSON } from '../transform/json'
+import { StatTypeEnum, GetValue } from '@cybertale/interface'
 
 /**
  * Generic value resolution from ObjectTemplate stats.
@@ -16,39 +14,5 @@ export function getValueFromTemplate(
     valueStat: StatTypeEnum,
     indexStat: StatTypeEnum = (StatTypeEnum as any).Option,
 ): unknown {
-  const raw = getStringStat(object, valueStat)
-  if (!raw) return ''
-
-  if (!hasStat(object, indexStat) || !isJSONArray(raw)) {
-    return raw
-  }
-
-  const data = parseJSON<unknown[]>(raw)
-  if (!data) return ''
-
-  const indexRaw = getStringStat(object, indexStat)
-
-  // JSON-array index case
-  if (isJSONArray(indexRaw)) {
-    const optionIndicesStat = (StatTypeEnum as any).OptionIndices as StatTypeEnum
-    const indices = parseJSON<number[]>(indexRaw) ?? []
-
-    const optionIndex = Number(getStringStat(object, optionIndicesStat))
-    const mappedIndex = indices[optionIndex]
-
-    // FIXED: redundant typeof removed, replaced with correct bounds + null check
-    if (mappedIndex != null && mappedIndex in data) {
-      return data[mappedIndex]
-    }
-
-    return ''
-  }
-
-  // Simple numeric index
-  const index = Number(indexRaw)
-  if (Number.isNaN(index) || !(index in data)) {
-    return ''
-  }
-
-  return data[index]
+  return GetValue(object, valueStat, indexStat)
 }

package/src/resolver/handlers/template.ts

@@ -0,0 +1,59 @@
+import { ObjectTemplate, StatTypeEnum } from '@cybertale/interface'
+import { v4 as uuidv4 } from 'uuid'
+import { insertTemplateAt } from './insert'
+import { findTemplateIndexByStat } from './remove'
+import { getStringStat } from '../transform/stat'
+
+export function cloneObjectTemplate(object: ObjectTemplate): ObjectTemplate {
+  return new ObjectTemplate(
+    object.Region,
+    object.ObjectEnum,
+    object.SubObjectEnum,
+    object.ActionEnum,
+    object.Stats,
+  )
+}
+
+export function appendTemplates(
+  templates: ObjectTemplate[],
+  newTemplates: ObjectTemplate[],
+): ObjectTemplate[] {
+  const appended = newTemplates.map(template => cloneObjectTemplate(template))
+  return [...templates, ...appended]
+}
+
+export function addInputGroupTemplate(
+  templates: ObjectTemplate[],
+  payload: ObjectTemplate,
+  options?: {
+    tagStat?: StatTypeEnum
+    elementTypeStat?: StatTypeEnum
+    idFactory?: () => string
+  },
+): ObjectTemplate[] {
+  const tagStat = options?.tagStat ?? StatTypeEnum.Tag
+  const elementTypeStat = options?.elementTypeStat ?? StatTypeEnum.ElementType
+  const idFactory = options?.idFactory ?? uuidv4
+
+  const payloadClone = cloneObjectTemplate(payload)
+  if (payloadClone.Stats?.[elementTypeStat]) {
+    payloadClone.Stats[elementTypeStat].Data = ''
+  }
+
+  const baseTag = getStringStat(payloadClone, tagStat)
+  let insertOffset = 0
+  for (const template of templates) {
+    const tagValue = getStringStat(template, tagStat)
+    if (tagValue.includes(baseTag)) {
+      insertOffset += 1
+    }
+  }
+
+  if (payloadClone.Stats?.[tagStat]) {
+    payloadClone.Stats[tagStat].Data = baseTag + idFactory()
+  }
+
+  const baseIndex = findTemplateIndexByStat(templates, baseTag, tagStat)
+  const insertIndex = baseIndex + insertOffset
+  return insertTemplateAt(templates, insertIndex, payloadClone)
+}

package/src/resolver/transform/json.ts

@@ -1,23 +1,5 @@
-
-// JSON-related transformation utilities for ObjectTemplate stats.
-// These are intentionally generic and environment-agnostic so they can be reused
-// both in browser and Node contexts.
-
-export function parseJSON<T = unknown>(value: string | null | undefined): T | null {
-  if (value == null || value === "") return null
-  try {
-    return JSON.parse(value) as T
-  } catch {
-    return null
-  }
-}
-
-export function isJSONArray(value: string | null | undefined): boolean {
-  const parsed = parseJSON(value)
-  return Array.isArray(parsed)
-}
-
-export function isJSONObject(value: string | null | undefined): boolean {
-  const parsed = parseJSON(value)
-  return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
-}
+export {
+  ParseJSON as parseJSON,
+  IsJSONArray as isJSONArray,
+  IsJSONObject as isJSONObject
+} from '@cybertale/interface'

package/src/resolver/transform/stat.ts

@@ -1,32 +1,7 @@
-
-import type { ObjectTemplate, StatTypeEnum } from '@cybertale/interface'
-import { parseJSON } from './json'
-
-// Safe stat accessors for ObjectTemplate. These centralize the common
-// patterns used across UI and resolver code.
-
-export function hasStat(object: ObjectTemplate, stat: StatTypeEnum): boolean {
-  return !!object.Stats && object.Stats[stat] !== undefined
-}
-
-export function getRawStat(object: ObjectTemplate, stat: StatTypeEnum): unknown {
-  return object.Stats?.[stat]?.Data
-}
-
-export function getStringStat(object: ObjectTemplate, stat: StatTypeEnum): string {
-  const raw = getRawStat(object, stat)
-  if (raw == null) return ''
-  return String(raw)
-}
-
-export function getBooleanStat(object: ObjectTemplate, stat: StatTypeEnum): boolean {
-  const raw = getRawStat(object, stat)
-  // Treat empty string / null / undefined as false, anything else as true.
-  return !!raw
-}
-
-export function getJSONStat<T = unknown>(object: ObjectTemplate, stat: StatTypeEnum): T | null {
-  const raw = getRawStat(object, stat)
-  if (typeof raw !== 'string') return null
-  return parseJSON<T>(raw)
-}
+export {
+  HasStat as hasStat,
+  GetRawStat as getRawStat,
+  GetStringStat as getStringStat,
+  GetBooleanStat as getBooleanStat,
+  GetJSONStat as getJSONStat
+} from '@cybertale/interface'