@code0-tech/pictor 0.0.0-mvp.10

package/dist/utils/generics.d.ts

@@ -0,0 +1,17 @@
+import { FunctionDefinitionView } from '../components/d-flow/function/DFlowFunction.view';
+import { DFlowDataTypeReactiveService } from '../components/d-flow/data-type/DFlowDataType.service';
+import { DataType, DataTypeIdentifier, GenericMapper, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
+import { FlowView } from '../components/d-flow/DFlow.view';
+type GenericMappingResult = Record<string, DataTypeIdentifier>;
+type GenericReplacement = DataTypeIdentifier | GenericMapper;
+type GenericMap = Map<string, GenericReplacement>;
+export declare const resolveGenericKeyMappings: (parameterType: DataTypeIdentifier, valueType: DataTypeIdentifier, genericKeys: string[]) => GenericMappingResult;
+export declare const replaceGenericKeysInType: (type: DataTypeIdentifier, genericMap: GenericMap) => DataTypeIdentifier;
+export declare const resolveAllGenericKeysInDataTypeObject: (genericObj: DataType, concreteObj: DataType, genericKeys: string[]) => Record<string, GenericReplacement | undefined>;
+export declare const replaceGenericKeysInDataTypeObject: (dataType: DataType, genericMap: GenericMap) => DataType;
+export declare const resolveGenericKeys: (func: FunctionDefinitionView, values: NodeParameterValue[], dataTypeService: DFlowDataTypeReactiveService, flow?: FlowView) => GenericMap;
+export declare function isMatchingDataTypeObject(source: DataType, target: DataType): boolean;
+export declare function isMatchingType(source: DataTypeIdentifier, target: DataTypeIdentifier): boolean;
+export declare const resolveType: (type: DataTypeIdentifier, service: DFlowDataTypeReactiveService) => DataTypeIdentifier;
+export declare const replaceGenericsAndSortType: (type: DataTypeIdentifier, genericKeys?: string[]) => DataTypeIdentifier;
+export {};

package/dist/utils/generics.js

@@ -0,0 +1,310 @@
+const C = "GENERIC", y = (e) => typeof e == "object" && e !== null && !Array.isArray(e), T = (e) => y(e) ? "genericKey" in e || "genericType" in e || "dataType" in e : !1, A = (e) => y(e) && "target" in e && Array.isArray(e.sourceDataTypeIdentifiers), E = (e) => y(e) && "variant" in e && "identifier" in e, b = (e) => y(e) && "variant" in e && "config" in e, O = (e) => {
+  if (e)
+    return typeof e == "string" ? e : e?.dataType?.identifier ?? e?.genericType?.dataType?.identifier ?? void 0;
+}, j = (e, n) => {
+  if (e)
+    return typeof e == "string" ? n && n.has(e) ? e : void 0 : e.genericKey ?? void 0;
+}, _ = (e) => !e || typeof e == "string" ? [] : e.genericType?.genericMappers ?? [], G = (e, n) => ({
+  ...e,
+  sourceDataTypeIdentifiers: n
+}), R = (e) => {
+  const n = e.genericCombinationStrategies ?? [];
+  return new Set(n.map((i) => i.type));
+}, m = (e) => {
+  if (Array.isArray(e))
+    return e.map(m);
+  if (y(e)) {
+    const n = {};
+    return Object.entries(e).forEach(([i, t]) => {
+      i === "__typename" || i === "id" || i === "createdAt" || i === "updatedAt" || (n[i] = m(t));
+    }), n;
+  }
+  return e;
+}, S = (e, n) => {
+  if (!n) return !e;
+  if (typeof n == "string")
+    return n === C ? !0 : O(e) === n;
+  if (n.genericKey) return !0;
+  const t = O(n), a = O(e);
+  return !!t && t === a;
+}, z = (e, n) => {
+  switch (e.__typename) {
+    case "DataTypeRulesContainsKeyConfig":
+    case "DataTypeRulesContainsTypeConfig":
+    case "DataTypeRulesReturnTypeConfig": {
+      const i = e.dataTypeIdentifier;
+      return i ? {
+        ...e,
+        dataTypeIdentifier: M(i, n)
+      } : e;
+    }
+    case "DataTypeRulesInputTypesConfig": {
+      const i = e, t = i.inputTypes?.map((a) => ({
+        ...a,
+        dataTypeIdentifier: M(a.dataTypeIdentifier, n)
+      }));
+      return {
+        ...i,
+        inputTypes: t
+      };
+    }
+    default:
+      return e;
+  }
+}, w = (e, n, i) => {
+  const t = {}, a = new Set(i), c = (s, r) => {
+    if (!s || !r) return;
+    const f = j(s, a);
+    if (f && a.has(f)) {
+      T(r) && (t[f] = r);
+      return;
+    }
+    const o = _(s);
+    if (o.length === 0) return;
+    const u = _(r);
+    for (const p of o) {
+      const l = u.find((g) => g.target === p.target);
+      if (!l) continue;
+      const d = (p.sourceDataTypeIdentifiers ?? []).map((g) => j(g, a)).filter((g) => !!g && a.has(g)), I = R(p), D = l.sourceDataTypeIdentifiers ?? [];
+      if ((I.has("AND") || I.has("OR")) && D.length === 1 && d.length === (p.sourceDataTypeIdentifiers?.length ?? 0))
+        for (const g of d)
+          t[g] = D[0];
+      else {
+        const g = Math.min(p.sourceDataTypeIdentifiers?.length ?? 0, D.length);
+        for (let K = 0; K < g; K++)
+          c(p.sourceDataTypeIdentifiers[K], D[K]);
+      }
+    }
+  };
+  return c(e, n), t;
+}, M = (e, n) => {
+  if (!T(e)) return e;
+  const {
+    genericKey: i,
+    genericType: t
+  } = e;
+  if (i && n.has(i)) {
+    const c = n.get(i);
+    return c && T(c) ? c : e;
+  }
+  if (!t) return e;
+  const a = (t.genericMappers ?? []).map((c) => {
+    const s = [];
+    for (const r of c.sourceDataTypeIdentifiers ?? []) {
+      if (!r) continue;
+      const f = r.genericKey;
+      if (f && n.has(f)) {
+        const o = n.get(f);
+        o && A(o) ? s.push(...o.sourceDataTypeIdentifiers) : o && T(o) ? s.push(o) : s.push(r);
+      } else T(r) ? s.push(M(r, n)) : s.push(r);
+    }
+    return G(c, s);
+  });
+  return {
+    ...e,
+    genericType: {
+      ...t,
+      genericMappers: a
+    }
+  };
+}, J = (e, n, i) => {
+  const t = {}, a = new Set(i), c = (s, r, f) => {
+    if (!(!s || !r || a.size === 0)) {
+      if (T(s)) {
+        const o = s.genericKey;
+        if (o && a.has(o) && (f ? t[o] = f : (A(r) || T(r)) && (t[o] = r), a.delete(o), a.size === 0))
+          return;
+      }
+      if (A(s) && A(r)) {
+        const o = Math.min(s.sourceDataTypeIdentifiers?.length, r.sourceDataTypeIdentifiers?.length);
+        for (let u = 0; u < o; u++)
+          if (c(s.sourceDataTypeIdentifiers[u], r.sourceDataTypeIdentifiers[u], r), a.size === 0) return;
+        return;
+      }
+      if (E(s) && E(r)) {
+        const o = s.rules?.nodes ?? [], u = r.rules?.nodes ?? [], p = Math.min(o.length, u.length);
+        for (let l = 0; l < p; l++) {
+          const d = o[l], I = u[l];
+          if (!(!d || !I) && (c(d, I), a.size === 0))
+            return;
+        }
+        return;
+      }
+      if (b(s) && b(r)) {
+        c(s.config, r.config);
+        return;
+      }
+      if (Array.isArray(s) && Array.isArray(r)) {
+        const o = Math.min(s.length, r.length);
+        for (let u = 0; u < o; u++)
+          if (c(s[u], r[u], f), a.size === 0) return;
+        return;
+      }
+      if (y(s) && y(r)) {
+        for (const o of Object.keys(s))
+          if (o in r && o !== "__typename" && (c(s[o], r[o], f), a.size === 0))
+            return;
+      }
+    }
+  };
+  return c(e, n), t;
+}, Y = (e, n) => {
+  const i = e.rules ? {
+    ...e.rules,
+    nodes: e.rules.nodes?.map((t) => t && {
+      ...t,
+      config: z(t.config, n)
+    })
+  } : void 0;
+  return {
+    ...e,
+    rules: i
+  };
+}, k = (e, n, i, t) => {
+  const a = /* @__PURE__ */ new Map(), c = e.genericKeys ?? [];
+  if (!e.parameterDefinitions || c.length <= 0) return a;
+  const s = new Set(c);
+  return e.parameterDefinitions.forEach((r, f) => {
+    const o = r.dataTypeIdentifier, u = n[f], p = i.getTypeFromValue(u, t);
+    if (!o || !p) return;
+    const l = w(o, p, c);
+    for (const [d, I] of Object.entries(l))
+      s.has(d) && (a.has(d) || a.set(d, I));
+  }), a;
+};
+function L(e, n) {
+  if (e.variant !== n.variant) return !1;
+  const i = n.rules?.nodes ?? [];
+  if (i.length === 0) return !0;
+  const t = e.rules?.nodes ?? [];
+  for (const a of i) {
+    if (!a) continue;
+    if (!t.some((s) => s ? x(s, a) : !1)) return !1;
+  }
+  return !0;
+}
+function x(e, n) {
+  if (e.variant !== n.variant) return !1;
+  switch (n.variant) {
+    case "CONTAINS_TYPE":
+    case "RETURN_TYPE":
+      return S(e.config.dataTypeIdentifier, n.config.dataTypeIdentifier);
+    case "CONTAINS_KEY": {
+      const i = e.config, t = n.config;
+      return i.key !== t.key ? !1 : S(i.dataTypeIdentifier, t.dataTypeIdentifier);
+    }
+    case "INPUT_TYPE": {
+      const i = e.config, a = n.config.inputTypes ?? [], c = i.inputTypes ?? [];
+      return a.every((s) => c.some((r) => S(r.dataTypeIdentifier, s.dataTypeIdentifier)));
+    }
+    case "ITEM_OF_COLLECTION": {
+      const i = e.config.items ?? [], t = n.config.items ?? [];
+      return i.length !== t.length ? !1 : i.every((a, c) => a === t[c]);
+    }
+    case "NUMBER_RANGE": {
+      const i = e.config, t = n.config;
+      return i.from === t.from && i.to === t.to && i.steps === t.steps;
+    }
+    case "REGEX": {
+      const i = e.config.pattern, t = n.config.pattern;
+      return i === t;
+    }
+    default:
+      return JSON.stringify(m(e.config)) === JSON.stringify(m(n.config));
+  }
+}
+function V(e, n) {
+  const i = (s) => !!(s === C || T(s) && s.genericKey), t = (s, r) => i(s) || i(r) ? !0 : s == null || r == null ? s === r : Array.isArray(r) ? !Array.isArray(s) || s.length !== r.length ? !1 : s.every((f, o) => t(f, r[o])) : y(r) ? y(s) ? Object.keys(r).every((o) => t(s[o], r[o])) : !1 : s === r, a = m(e), c = m(n);
+  return t(a, c);
+}
+const P = (e, n) => {
+  if (typeof e == "string") {
+    const t = n.getDataType(e);
+    if (!t) return e;
+    const a = t.genericKeys ?? [];
+    if (t.variant === "ARRAY" && a.length > 0) {
+      const s = t.rules?.nodes?.find((r) => r?.variant === "CONTAINS_TYPE")?.config?.dataTypeIdentifier;
+      if (s) {
+        const [r] = a;
+        return r ? {
+          dataType: t.json,
+          genericType: {
+            dataType: t.json,
+            genericMappers: [{
+              target: r,
+              sourceDataTypeIdentifiers: [P(s, n)]
+            }]
+          }
+        } : e;
+      }
+    }
+    return e;
+  }
+  if (!T(e) || !e.genericType) return e;
+  const i = e.genericType.genericMappers?.map((t) => ({
+    ...t,
+    sourceDataTypeIdentifiers: t?.sourceDataTypeIdentifiers?.map((a) => P(a, n))
+  })) ?? [];
+  return {
+    ...e,
+    genericType: {
+      ...e.genericType,
+      genericMappers: i
+    }
+  };
+}, h = (e) => {
+  if (Array.isArray(e)) {
+    const n = e.map(h);
+    return n.length <= 1 ? n : n.every(y) ? [...n].sort((a, c) => JSON.stringify(a).localeCompare(JSON.stringify(c))) : n.every((a) => !Array.isArray(a) && !y(a)) ? [...n].sort((a, c) => JSON.stringify(a).localeCompare(JSON.stringify(c))) : n;
+  }
+  if (y(e)) {
+    const n = e;
+    return Object.keys(n).sort().reduce((i, t) => (i[t] = h(n[t]), i), {});
+  }
+  return e;
+}, F = (e, n = []) => {
+  const i = new Set(n), t = (r) => r ? i.size === 0 ? !0 : i.has(r) : !1, a = (r) => {
+    const o = t(r.target) ? C : r.target, u = (r.sourceDataTypeIdentifiers ?? []).map((p) => s(p));
+    return h({
+      ...r,
+      target: o,
+      sourceDataTypeIdentifiers: u
+    });
+  }, c = (r) => {
+    const o = t(r.genericKey) ? C : r.genericKey, u = {
+      ...r,
+      genericKey: o,
+      dataType: r.dataType ? s(r.dataType) : r.dataType,
+      genericType: r.genericType ? s(r.genericType) : r.genericType
+    };
+    return h(u);
+  };
+  function s(r) {
+    if (r == null) return r;
+    if (Array.isArray(r)) {
+      const f = r.map((o) => s(o));
+      return h(f);
+    }
+    if (T(r))
+      return c(r);
+    if (A(r))
+      return a(r);
+    if (y(r)) {
+      const f = Object.entries(r).reduce((o, [u, p]) => (o[u] = s(p), o), {});
+      return h(f);
+    }
+    return r;
+  }
+  return s(e);
+};
+export {
+  L as isMatchingDataTypeObject,
+  V as isMatchingType,
+  Y as replaceGenericKeysInDataTypeObject,
+  M as replaceGenericKeysInType,
+  F as replaceGenericsAndSortType,
+  J as resolveAllGenericKeysInDataTypeObject,
+  w as resolveGenericKeyMappings,
+  k as resolveGenericKeys,
+  P as resolveType
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,8 @@
+export * from './arrayService';
+export * from './contextStore';
+export * from './inspection';
+export * from './nonReactiveArrayService';
+export * from './objectStore';
+export * from './reactiveArrayService';
+export * from './types';
+export * from './utils';

package/dist/utils/index.js

@@ -0,0 +1,28 @@
+import { ContextStore as o, ContextStoreProvider as t, useService as i, useStore as c } from "./contextStore.js";
+import { InspectionSeverity as v } from "./inspection.js";
+import { NonReactiveArrayService as S, createNonReactiveArrayService as p } from "./nonReactiveArrayService.js";
+import { ObjectService as g, createObjectService as x } from "./objectStore.js";
+import { ReactiveArrayService as f, useReactiveArrayService as C } from "./reactiveArrayService.js";
+import { Colors as y } from "./types.js";
+import { getChild as P, getContent as u, getPositionAroundTarget as R, getPositioning as b, getWindowPositioning as j, mergeCode0Props as l, parseUnit as N } from "./utils.js";
+export {
+  y as Colors,
+  o as ContextStore,
+  t as ContextStoreProvider,
+  v as InspectionSeverity,
+  S as NonReactiveArrayService,
+  g as ObjectService,
+  f as ReactiveArrayService,
+  p as createNonReactiveArrayService,
+  x as createObjectService,
+  P as getChild,
+  u as getContent,
+  R as getPositionAroundTarget,
+  b as getPositioning,
+  j as getWindowPositioning,
+  l as mergeCode0Props,
+  N as parseUnit,
+  C as useReactiveArrayService,
+  i as useService,
+  c as useStore
+};

package/dist/utils/inspection.d.ts

@@ -0,0 +1,13 @@
+import { Maybe, Scalars, TranslationConnection } from '@code0-tech/sagittarius-graphql-types';
+export declare enum InspectionSeverity {
+    TYPO = 0,
+    GRAMMAR = 1,
+    WEAK = 2,
+    WARNING = 3,
+    ERROR = 4
+}
+export interface ValidationResult {
+    parameterId: Maybe<Scalars["ParameterDefinitionID"]["output"]>;
+    type: InspectionSeverity;
+    message: TranslationConnection;
+}

package/dist/utils/inspection.js

@@ -0,0 +1,4 @@
+var A = /* @__PURE__ */ ((R) => (R[R.TYPO = 0] = "TYPO", R[R.GRAMMAR = 1] = "GRAMMAR", R[R.WEAK = 2] = "WEAK", R[R.WARNING = 3] = "WARNING", R[R.ERROR = 4] = "ERROR", R))(A || {});
+export {
+  A as InspectionSeverity
+};

package/dist/utils/nonReactiveArrayService.d.ts

@@ -0,0 +1,19 @@
+import { ArrayService } from './arrayService';
+/**
+ * using a React ref as a store in combination with a map
+ * to be able to access and modify the store easily
+ */
+export type NonReactiveArrayStore<K> = K[];
+export declare class NonReactiveArrayService<T> implements ArrayService<T> {
+    protected store: NonReactiveArrayStore<T>;
+    constructor(store: NonReactiveArrayStore<T>);
+    delete(index: number): void;
+    add(value: T): void;
+    set(index: number, value: T): void;
+    has(index: number): boolean;
+    get(index: number): T;
+    values(): NonReactiveArrayStore<T>;
+    update(): void;
+    clear(): void;
+}
+export declare const createNonReactiveArrayService: <K, T extends ArrayService<K>>(service: typeof T, callback?: (store: NonReactiveArrayStore<K>) => T) => [K[] | undefined, T];

package/dist/utils/nonReactiveArrayService.js

@@ -0,0 +1,54 @@
+function o(t, e, r) {
+  return (e = s(e)) in t ? Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : t[e] = r, t;
+}
+function s(t) {
+  var e = n(t, "string");
+  return typeof e == "symbol" ? e : e + "";
+}
+function n(t, e) {
+  if (typeof t != "object" || !t) return t;
+  var r = t[Symbol.toPrimitive];
+  if (r !== void 0) {
+    var i = r.call(t, e);
+    if (typeof i != "object") return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(t);
+}
+class u {
+  constructor(e) {
+    o(this, "store", void 0), this.store = e;
+  }
+  delete(e) {
+    delete this.store[e];
+  }
+  add(e) {
+    this.store.push(e);
+  }
+  set(e, r) {
+    this.store[e] = r;
+  }
+  has(e) {
+    return !!this.store[e];
+  }
+  get(e) {
+    return this.store[e];
+  }
+  values() {
+    return this.store;
+  }
+  update() {
+    this.store = [...this.store];
+  }
+  clear() {
+    this.store = [];
+  }
+}
+const a = (t, e) => {
+  const r = [];
+  return [r, e ? e(r) : new t(r)];
+};
+export {
+  u as NonReactiveArrayService,
+  a as createNonReactiveArrayService
+};

package/dist/utils/objectStore.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+/**
+ * using a React ref as a store in combination with a map
+ * to be able to access and modify the store easily
+ */
+export type ObjectStore<K> = [K | undefined, React.Dispatch<React.SetStateAction<K>>];
+export declare class ObjectService<K> {
+    protected readonly store: ObjectStore<K>;
+    constructor(store: ObjectStore<K>);
+    object(): K | undefined;
+}
+export declare const createObjectService: <K, T extends ObjectService<K>>(service: typeof T, callback?: (store: ObjectStore<K>) => T, initial?: K) => [K | undefined, T];

package/dist/utils/objectStore.js

@@ -0,0 +1,34 @@
+import o from "react";
+function n(e, r, t) {
+  return (r = u(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e;
+}
+function u(e) {
+  var r = c(e, "string");
+  return typeof r == "symbol" ? r : r + "";
+}
+function c(e, r) {
+  if (typeof e != "object" || !e) return e;
+  var t = e[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var i = t.call(e, r);
+    if (typeof i != "object") return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (r === "string" ? String : Number)(e);
+}
+class f {
+  constructor(r) {
+    n(this, "store", void 0), this.store = r;
+  }
+  object() {
+    return this.store[0];
+  }
+}
+const v = (e, r, t) => {
+  const i = o.useState(t);
+  return [i[0], r ? r(i) : new e(i)];
+};
+export {
+  f as ObjectService,
+  v as createObjectService
+};

package/dist/utils/reactiveArrayService.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { ArrayService } from './arrayService';
+export type ReactiveArrayStore<T> = {
+    getState: () => T[];
+    setState: React.Dispatch<React.SetStateAction<T[]>>;
+};
+export declare class ReactiveArrayService<T> implements ArrayService<T> {
+    protected readonly access: ReactiveArrayStore<T>;
+    constructor(access: ReactiveArrayStore<T>);
+    delete(index: number): void;
+    add(value: T): void;
+    set(index: number, value: T): void;
+    has(index: number): boolean;
+    get(index: number): T;
+    values(): T[];
+    update(): void;
+    clear(): void;
+}
+type ArrayServiceCtor<K, S extends ArrayService<K>> = new (access: ReactiveArrayStore<K>) => S;
+type InitialArg<K, S extends ArrayService<K>> = K[] | ((svc: S) => K[]);
+export declare function useReactiveArrayService<K, S extends ArrayService<K>>(Ctor: ArrayServiceCtor<K, S> | ((store: ReactiveArrayStore<K>) => S), initial?: InitialArg<K, S>): [K[], S];
+export {};

package/dist/utils/reactiveArrayService.js

@@ -0,0 +1,91 @@
+import n, { startTransition as a } from "react";
+function v(t, e, r) {
+  return (e = y(e)) in t ? Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : t[e] = r, t;
+}
+function y(t) {
+  var e = h(t, "string");
+  return typeof e == "symbol" ? e : e + "";
+}
+function h(t, e) {
+  if (typeof t != "object" || !t) return t;
+  var r = t[Symbol.toPrimitive];
+  if (r !== void 0) {
+    var s = r.call(t, e);
+    if (typeof s != "object") return s;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(t);
+}
+class b {
+  constructor(e) {
+    v(this, "access", void 0), this.access = e;
+  }
+  delete(e) {
+    a(() => {
+      this.access.setState((r) => r.filter((s, c) => c !== e));
+    });
+  }
+  add(e) {
+    a(() => {
+      this.access.setState((r) => [...r, e]);
+    });
+  }
+  set(e, r) {
+    a(() => {
+      this.access.setState((s) => {
+        const c = s.slice();
+        return c[e] = r, c;
+      });
+    });
+  }
+  has(e) {
+    const r = this.access.getState();
+    return e >= 0 && e < r.length;
+  }
+  get(e) {
+    return this.access.getState()[e];
+  }
+  values() {
+    return this.access.getState();
+  }
+  update() {
+    a(() => {
+      this.access.setState((e) => e.slice());
+    });
+  }
+  clear() {
+    a(() => {
+      this.access.setState(() => []);
+    });
+  }
+}
+function g(t, e = []) {
+  const [r, s] = n.useState(Array.isArray(e) ? e : []), c = n.useRef(r);
+  n.useEffect(() => {
+    c.current = r;
+  }, [r]);
+  const u = n.useCallback(() => c.current, []), o = n.useMemo(() => {
+    const i = {
+      getState: u,
+      setState: s
+    }, f = {
+      construct() {
+        return f;
+      }
+    };
+    return ((l) => {
+      try {
+        return !!new new Proxy(l, f)();
+      } catch {
+        return !1;
+      }
+    })(t) ? new t(i) : t(i);
+  }, [t, u, s]);
+  return n.useEffect(() => {
+    typeof e == "function" && s(e(o));
+  }, [o, e]), [r, o];
+}
+export {
+  b as ReactiveArrayService,
+  g as useReactiveArrayService
+};

package/dist/utils/types.d.ts

@@ -0,0 +1,57 @@
+import { default as React, HTMLProps } from 'react';
+export type Color = "primary" | "secondary" | "info" | "success" | "warning" | "error";
+export declare const Colors: Color[];
+export type Code0Sizes = "xxs" | "xs" | "sm" | "md" | "lg" | "xl";
+export type Code0FontSizes = "0.35" | "0.7" | "0.8" | "1" | "1.2" | "1.3";
+export type StyleProp<Value> = Value;
+export interface Code0ComponentProps {
+    m?: StyleProp<number | `${number}`>;
+    my?: StyleProp<number | `${number}`>;
+    mx?: StyleProp<number | `${number}`>;
+    mt?: StyleProp<number | `${number}`>;
+    mb?: StyleProp<number | `${number}`>;
+    ml?: StyleProp<number | `${number}`>;
+    mr?: StyleProp<number | `${number}`>;
+    p?: StyleProp<number | `${number}`>;
+    py?: StyleProp<number | `${number}`>;
+    px?: StyleProp<number | `${number}`>;
+    pt?: StyleProp<number | `${number}`>;
+    pb?: StyleProp<number | `${number}`>;
+    pl?: StyleProp<number | `${number}`>;
+    pr?: StyleProp<number | `${number}`>;
+    bg?: React.CSSProperties['backgroundColor'];
+    c?: React.CSSProperties['color'];
+    opacity?: React.CSSProperties['opacity'];
+    ff?: StyleProp<'mono' | 'text' | 'heading' | (string & {})>;
+    fz?: StyleProp<Code0FontSizes | number | `${number}`>;
+    fw?: StyleProp<React.CSSProperties['fontWeight']>;
+    lts?: StyleProp<React.CSSProperties['letterSpacing']>;
+    ta?: StyleProp<React.CSSProperties['textAlign']>;
+    lh?: StyleProp<number | (string & {})>;
+    fs?: StyleProp<React.CSSProperties['fontStyle']>;
+    tt?: StyleProp<React.CSSProperties['textTransform']>;
+    td?: StyleProp<React.CSSProperties['textDecoration']>;
+    w?: StyleProp<React.CSSProperties['width']>;
+    miw?: StyleProp<React.CSSProperties['minWidth']>;
+    maw?: StyleProp<React.CSSProperties['maxWidth']>;
+    h?: StyleProp<React.CSSProperties['height']>;
+    mih?: StyleProp<React.CSSProperties['minHeight']>;
+    mah?: StyleProp<React.CSSProperties['maxHeight']>;
+    bgsz?: StyleProp<React.CSSProperties['backgroundSize']>;
+    bgp?: StyleProp<React.CSSProperties['backgroundPosition']>;
+    bgr?: StyleProp<React.CSSProperties['backgroundRepeat']>;
+    bga?: StyleProp<React.CSSProperties['backgroundAttachment']>;
+    pos?: StyleProp<React.CSSProperties['position']>;
+    top?: StyleProp<React.CSSProperties['top']>;
+    left?: StyleProp<React.CSSProperties['left']>;
+    bottom?: StyleProp<React.CSSProperties['bottom']>;
+    right?: StyleProp<React.CSSProperties['right']>;
+    inset?: StyleProp<React.CSSProperties['inset']>;
+    display?: StyleProp<React.CSSProperties['display']>;
+    flex?: StyleProp<React.CSSProperties['flex']>;
+    align?: StyleProp<React.CSSProperties['alignItems']>;
+    justify?: StyleProp<React.CSSProperties['justifyContent']>;
+    tf?: StyleProp<React.CSSProperties['transform']>;
+}
+export interface Code0Component<T> extends Code0ComponentProps, HTMLProps<T> {
+}

package/dist/utils/types.js

@@ -0,0 +1,4 @@
+const r = ["primary", "secondary", "info", "success", "warning", "error"];
+export {
+  r as Colors
+};