@code0-tech/pictor 0.3.0 → 0.4.0

package/dist/node_modules/react/cjs/react-compiler-runtime.development.js

@@ -0,0 +1,21 @@
+import { __exports as e } from "../../../_virtual/react-compiler-runtime.development.js";
+import a from "react";
+var n;
+function s() {
+  return n ? e : (n = 1, process.env.NODE_ENV !== "production" && (function() {
+    var t = a.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+    e.c = function(r) {
+      var o = t.H;
+      return o === null && console.error(
+        `Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`
+      ), o.useMemoCache(r);
+    };
+  })(), e);
+}
+export {
+  s as __require
+};

package/dist/node_modules/react/cjs/react-compiler-runtime.production.js

@@ -0,0 +1,14 @@
+import { __exports as r } from "../../../_virtual/react-compiler-runtime.production.js";
+import o from "react";
+var e;
+function u() {
+  if (e) return r;
+  e = 1;
+  var t = o.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+  return r.c = function(_) {
+    return t.H.useMemoCache(_);
+  }, r;
+}
+export {
+  u as __require
+};

package/dist/node_modules/react/compiler-runtime.js

@@ -0,0 +1,10 @@
+import { __module as e } from "../../_virtual/compiler-runtime2.js";
+import { __require as i } from "./cjs/react-compiler-runtime.production.js";
+import { __require as o } from "./cjs/react-compiler-runtime.development.js";
+var r;
+function p() {
+  return r ? e.exports : (r = 1, process.env.NODE_ENV === "production" ? e.exports = i() : e.exports = o(), e.exports);
+}
+export {
+  p as __require
+};

package/dist/utils/arrayService.d.ts

@@ -0,0 +1,10 @@
+export interface ArrayService<I, R, D = Record<string, any>> {
+    delete(index: number): void;
+    add(index: I): void;
+    set(index: number, value: I): void;
+    has(index: number): boolean;
+    get(index: number): R;
+    values(dependencies?: D): R[];
+    update(): void;
+    clear(): void;
+}

package/dist/utils/arrayService.js

@@ -0,0 +1 @@
+

package/dist/utils/contextStore.d.ts

@@ -0,0 +1,62 @@
+import { default as React, ReactNode } from 'react';
+/**
+ * Type representing a concrete class constructor.
+ */
+export type ConcreteCtor<T> = new (...args: any[]) => T;
+/**
+ * Type representing an abstract class constructor.
+ */
+export type AbstractCtor<T> = abstract new (...args: any[]) => T;
+/**
+ * A class constructor type that can be either concrete or abstract.
+ */
+export type ServiceClass<T> = ConcreteCtor<T> | AbstractCtor<T>;
+/**
+ * Tuple representing a service entry: [store, service].
+ */
+export type ServiceEntry<T = any> = [any, T];
+/**
+ * Map storing service entries, keyed by their (abstract or concrete) class constructor.
+ */
+export type ServiceMap = Map<Function, ServiceEntry>;
+/**
+ * React Context for providing and consuming registered services and stores.
+ */
+export declare const ContextStore: React.Context<ServiceMap | null>;
+/**
+ * Props for the ContextStoreProvider component.
+ * @property services - Array of [store, service] tuples to register.
+ * @property children - React children to render within the provider.
+ */
+export type ContextStoreProviderProps = {
+    services: ServiceEntry[];
+    children: ReactNode;
+};
+/**
+ * ContextStoreProvider
+ *
+ * Registers all given services and their associated stores in a shared context.
+ *
+ * Each service is indexed by both its concrete constructor and all abstract or
+ * base class constructors in its prototype chain.
+ *
+ * If multiple services share the same base class, the first one wins (no overwriting).
+ */
+export declare const ContextStoreProvider: React.FC<ContextStoreProviderProps>;
+/**
+ * Retrieves a service instance from the ContextStore by its class.
+ * Works with both concrete classes and abstract base classes.
+ *
+ * @param ServiceClass - The (abstract or concrete) class of the desired service.
+ * @returns The matching service instance.
+ * @throws If the context or service cannot be found.
+ */
+export declare const useService: <T>(ServiceClass: ServiceClass<T>) => T;
+/**
+ * Retrieves the store associated with a (concrete or abstract) service class.
+ *
+ * @param ServiceClass - The (abstract or concrete) class whose store should be retrieved.
+ * @returns The store instance associated with the given service.
+ * @throws If the context or store cannot be found.
+ */
+export declare const useStore: <T>(ServiceClass: ServiceClass<T>) => any;

package/dist/utils/contextStore.js

@@ -0,0 +1,60 @@
+import { jsx as x } from "react/jsx-runtime";
+import { c as i } from "../_virtual/compiler-runtime.js";
+import { createContext as d, useContext as a } from "react";
+const u = d(null);
+function C(n) {
+  const t = [];
+  let o = Object.getPrototypeOf(n);
+  for (; o && o.constructor && o !== Object.prototype; ) {
+    const e = o.constructor;
+    t.push(e), o = Object.getPrototypeOf(o);
+  }
+  return t;
+}
+const g = (n) => {
+  const t = i.c(5), {
+    services: o,
+    children: e
+  } = n;
+  let r;
+  t[0] !== o ? (r = /* @__PURE__ */ new Map(), o.forEach((h) => {
+    const [p, f] = h, m = f.constructor;
+    r.has(m) || r.set(m, [p, f]);
+    const l = C(f);
+    for (const w of l)
+      r.has(w) || r.set(w, [p, f]);
+  }), t[0] = o, t[1] = r) : r = t[1];
+  const c = r;
+  let s;
+  return t[2] !== e || t[3] !== c ? (s = /* @__PURE__ */ x(u.Provider, { value: c, children: e }), t[2] = e, t[3] = c, t[4] = s) : s = t[4], s;
+}, O = (n) => {
+  const t = i.c(3), o = a(u);
+  if (!o)
+    throw new Error("ContextStore not found");
+  let e;
+  t[0] !== n || t[1] !== o ? (e = o.get(n), t[0] = n, t[1] = o, t[2] = e) : e = t[2];
+  const r = e;
+  if (!r) {
+    const c = n?.name ?? "UnknownServiceClass";
+    throw new Error(`Service not found for ${c}`);
+  }
+  return r[1];
+}, P = (n) => {
+  const t = i.c(3), o = a(u);
+  if (!o)
+    throw new Error("ContextStore not found");
+  let e;
+  t[0] !== n || t[1] !== o ? (e = o.get(n), t[0] = n, t[1] = o, t[2] = e) : e = t[2];
+  const r = e;
+  if (!r) {
+    const c = n?.name ?? "UnknownServiceClass";
+    throw new Error(`Store not found for ${c}`);
+  }
+  return r[0];
+};
+export {
+  u as ContextStore,
+  g as ContextStoreProvider,
+  O as useService,
+  P as useStore
+};

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,25 @@
+import { ContextStore as o, ContextStoreProvider as t, useService as i, useStore as c } from "./contextStore.js";
+import { InspectionSeverity as S, underlineBySeverity as a } from "./inspection.js";
+import { NonReactiveArrayService as p, createNonReactiveArrayService as x } from "./nonReactiveArrayService.js";
+import { ObjectService as f, createObjectService as s } from "./objectStore.js";
+import { ReactiveArrayService as C, useReactiveArrayService as d } from "./reactiveArrayService.js";
+import { Colors as A } from "./types.js";
+import { getDOMSizeFromCodeZeroSize as l, hashToColor as O, mergeCode0Props as b } from "./utils.js";
+export {
+  A as Colors,
+  o as ContextStore,
+  t as ContextStoreProvider,
+  S as InspectionSeverity,
+  p as NonReactiveArrayService,
+  f as ObjectService,
+  C as ReactiveArrayService,
+  x as createNonReactiveArrayService,
+  s as createObjectService,
+  l as getDOMSizeFromCodeZeroSize,
+  O as hashToColor,
+  b as mergeCode0Props,
+  a as underlineBySeverity,
+  d as useReactiveArrayService,
+  i as useService,
+  c as useStore
+};

package/dist/utils/inspection.d.ts

@@ -0,0 +1,15 @@
+import { NodeParameter, Translation } from '@code0-tech/sagittarius-graphql-types';
+import { CSSProperties } from 'react';
+export declare enum InspectionSeverity {
+    TYPO = 0,
+    GRAMMAR = 1,
+    WEAK = 2,
+    WARNING = 3,
+    ERROR = 4
+}
+export interface ValidationResult {
+    parameterId: NodeParameter['id'];
+    type: InspectionSeverity;
+    message: Array<Translation>;
+}
+export declare const underlineBySeverity: Record<InspectionSeverity, CSSProperties>;

package/dist/utils/inspection.js

@@ -0,0 +1,29 @@
+var r = /* @__PURE__ */ ((d) => (d[d.TYPO = 0] = "TYPO", d[d.GRAMMAR = 1] = "GRAMMAR", d[d.WEAK = 2] = "WEAK", d[d.WARNING = 3] = "WARNING", d[d.ERROR = 4] = "ERROR", d))(r || {});
+const o = (d, a = "5px 4px") => ({
+  paddingBottom: "0.2rem",
+  backgroundRepeat: "repeat-x",
+  backgroundPosition: "left bottom",
+  backgroundSize: a,
+  backgroundImage: `url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='12' height='6' viewBox='0 0 12 6'>  <path d='M0 3 Q3 0 6 3 T12 3' fill='none' stroke='${d}' stroke-width='2'/></svg>")`
+}), g = {
+  0: {
+    borderBottom: "1px dotted #3b82f6"
+    // blue
+  },
+  1: {
+    borderBottom: "1px dashed #8b5cf6"
+    // violet
+  },
+  2: {
+    borderBottom: "3px double #9ca3af"
+    // gray
+  },
+  3: o("orange"),
+  // amber
+  4: o("red")
+  // already yours
+};
+export {
+  r as InspectionSeverity,
+  g as underlineBySeverity
+};

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, 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,23 @@
+import { default as React } from 'react';
+import { ArrayService } from './arrayService';
+import { Payload, View } from './view';
+export type ReactiveArrayStore<T> = {
+    getState: () => T[];
+    setState: React.Dispatch<React.SetStateAction<T[]>>;
+};
+export declare class ReactiveArrayService<T extends Payload, D = Record<string, any>> implements ArrayService<View<T>, T, D> {
+    protected readonly access: ReactiveArrayStore<View<T>>;
+    constructor(access: ReactiveArrayStore<View<T>>);
+    delete(index: number): void;
+    add(value: View<T>): void;
+    set(index: number, value: View<T>): void;
+    has(index: number): boolean;
+    get(index: number): T;
+    values(_dependencies?: D): T[];
+    update(): void;
+    clear(): void;
+}
+type ArrayServiceCtor<I, R, S extends ArrayService<I, R>> = new (access: ReactiveArrayStore<I>) => S;
+type InitialArg<R> = R[];
+export declare function useReactiveArrayService<R extends Payload, S extends ArrayService<View<R>, R>>(Ctor: ArrayServiceCtor<View<R>, R, S> | ((store: ReactiveArrayStore<View<R>>) => S), initial?: InitialArg<R>): [View<R>[], S];
+export {};

package/dist/utils/reactiveArrayService.js

@@ -0,0 +1,90 @@
+import a, { startTransition as i } from "react";
+import { View as h } from "./view.js";
+function p(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 = m(t, "string");
+  return typeof e == "symbol" ? e : e + "";
+}
+function m(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 w {
+  constructor(e) {
+    p(this, "access", void 0), this.access = e;
+  }
+  delete(e) {
+    i(() => {
+      this.access.setState((r) => r.filter((s, c) => c !== e));
+    });
+  }
+  add(e) {
+    i(() => {
+      this.access.setState((r) => [...r, e]);
+    });
+  }
+  set(e, r) {
+    i(() => {
+      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]?.payload;
+  }
+  values(e) {
+    return this.access.getState().map((r) => r.payload);
+  }
+  update() {
+    i(() => {
+      this.access.setState((e) => [...e]);
+    });
+  }
+  clear() {
+    i(() => {
+      this.access.setState(() => []);
+    });
+  }
+}
+function P(t, e = []) {
+  const [r, s] = a.useState([]), c = a.useRef([]);
+  c.current = r;
+  const u = a.useCallback(() => c.current, []), o = a.useMemo(() => {
+    const n = {
+      getState: u,
+      setState: s
+    }, v = {
+      construct: () => v
+    };
+    return ((d) => {
+      try {
+        return !!new new Proxy(d, v)();
+      } catch {
+        return !1;
+      }
+    })(t) ? new t(n) : t(n);
+  }, [t, u]), f = a.useCallback((n) => new h(n), []), l = a.useRef(!1);
+  return a.useEffect(() => {
+    l.current || (l.current = !0, o.clear(), e.forEach((n) => {
+      o.add(f(n));
+    }));
+  }, [o, e, f]), [r, o];
+}
+export {
+  w as ReactiveArrayService,
+  P as useReactiveArrayService
+};

package/dist/{cjs/utils → utils}/types.d.ts

@@ -1,8 +1,8 @@
-import React, { HTMLProps } from "react";
-export type Color = "primary" | "secondary" | "info" | "success" | "warning" | "error";
+import { default as React, HTMLProps } from 'react';
+export type Color = "primary" | "secondary" | "tertiary" | "info" | "success" | "warning" | "error";
 export declare const Colors: Color[];
-export type Code0Sizes = "xs" | "sm" | "md" | "lg" | "xl";
-export type Code0FontSizes = "0.75" | "0.8" | "1" | "1.2" | "1.25";
+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}`>;

package/dist/utils/types.js

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

package/dist/utils/utils.d.ts

@@ -0,0 +1,55 @@
+import { CSSProperties } from 'react';
+import { Code0Sizes } from './types';
+export declare const mergeCode0Props: (cn: string, rest: object) => {
+    m?: import('./types').StyleProp<number | `${number}`> | undefined;
+    my?: import('./types').StyleProp<number | `${number}`> | undefined;
+    mx?: import('./types').StyleProp<number | `${number}`> | undefined;
+    mt?: import('./types').StyleProp<number | `${number}`> | undefined;
+    mb?: import('./types').StyleProp<number | `${number}`> | undefined;
+    ml?: import('./types').StyleProp<number | `${number}`> | undefined;
+    mr?: import('./types').StyleProp<number | `${number}`> | undefined;
+    p?: import('./types').StyleProp<number | `${number}`> | undefined;
+    py?: import('./types').StyleProp<number | `${number}`> | undefined;
+    px?: import('./types').StyleProp<number | `${number}`> | undefined;
+    pt?: import('./types').StyleProp<number | `${number}`> | undefined;
+    pb?: import('./types').StyleProp<number | `${number}`> | undefined;
+    pl?: import('./types').StyleProp<number | `${number}`> | undefined;
+    pr?: import('./types').StyleProp<number | `${number}`> | undefined;
+    bg?: import("csstype").Property.BackgroundColor | undefined;
+    c?: import("csstype").Property.Color | undefined;
+    opacity?: import("csstype").Property.Opacity | undefined;
+    ff?: import('./types').StyleProp<"mono" | "text" | "heading" | (string & {})> | undefined;
+    fz?: import('./types').StyleProp<import('./types').Code0FontSizes | number | `${number}`> | undefined;
+    fw?: import("csstype").Property.FontWeight | undefined;
+    lts?: import("csstype").Property.LetterSpacing<string | number> | undefined;
+    ta?: import("csstype").Property.TextAlign | undefined;
+    lh?: import('./types').StyleProp<number | (string & {})> | undefined;
+    fs?: import("csstype").Property.FontStyle | undefined;
+    tt?: import("csstype").Property.TextTransform | undefined;
+    td?: import("csstype").Property.TextDecoration<string | number> | undefined;
+    w?: import("csstype").Property.Width<string | number> | undefined;
+    miw?: import("csstype").Property.MinWidth<string | number> | undefined;
+    maw?: import("csstype").Property.MaxWidth<string | number> | undefined;
+    h?: import("csstype").Property.Height<string | number> | undefined;
+    mih?: import("csstype").Property.MinHeight<string | number> | undefined;
+    mah?: import("csstype").Property.MaxHeight<string | number> | undefined;
+    bgsz?: import("csstype").Property.BackgroundSize<string | number> | undefined;
+    bgp?: import("csstype").Property.BackgroundPosition<string | number> | undefined;
+    bgr?: import("csstype").Property.BackgroundRepeat | undefined;
+    bga?: import("csstype").Property.BackgroundAttachment | undefined;
+    pos?: import("csstype").Property.Position | undefined;
+    top?: import("csstype").Property.Top<string | number> | undefined;
+    left?: import("csstype").Property.Left<string | number> | undefined;
+    bottom?: import("csstype").Property.Bottom<string | number> | undefined;
+    right?: import("csstype").Property.Right<string | number> | undefined;
+    inset?: import("csstype").Property.Inset<string | number> | undefined;
+    display?: import("csstype").Property.Display | undefined;
+    flex?: import("csstype").Property.Flex<string | number> | undefined;
+    align?: import("csstype").Property.AlignItems | undefined;
+    justify?: import("csstype").Property.JustifyContent | undefined;
+    tf?: import("csstype").Property.Transform | undefined;
+    style?: CSSProperties | undefined;
+    className: string;
+};
+export declare const getDOMSizeFromCodeZeroSize: (size: Code0Sizes | CSSProperties["x"]) => CSSProperties["x"];
+export declare const hashToColor: (s: string, from?: number, to?: number) => string;