andesine 0.0.1-alpha.0

package/dist/extensions.d.ts

@@ -0,0 +1,351 @@
+import { C as Client } from './shared/andesine.bcb7a57d.js';
+import { a as ContentPieceWithAdditionalData, J as JSONContent } from './shared/andesine.5e4b2db8.js';
+
+type ContextValue = string | number | boolean | undefined | null | ContextObject | ContextArray;
+type ContextObject = {
+    [x: string]: ContextValue;
+};
+type ContextArray = Array<ContextValue>;
+type IsFunction<T, R, Fallback = T> = T extends (...args: any[]) => any ? R : Fallback;
+type IsObject<T, R, Fallback = T> = IsFunction<T, Fallback, T extends object ? (T extends any[] ? Fallback : R) : Fallback>;
+type Tail<S> = S extends `${string}.${infer T}` ? Tail<T> : S;
+type Value<T> = T[keyof T];
+type FlattenStepOne<T> = {
+    [K in keyof T as K extends string ? IsObject<T[K], `${K}.${keyof T[K] & string}`, K> : K]: IsObject<T[K], {
+        [key in keyof T[K]]: T[K][key];
+    }>;
+};
+type FlattenStepTwo<T> = {
+    [a in keyof T]: IsObject<T[a], Value<{
+        [M in keyof T[a] as M extends Tail<a> ? M : never]: T[a][M];
+    }>>;
+};
+type FlattenOneLevel<T> = FlattenStepTwo<FlattenStepOne<T>>;
+type Flatten<T> = T extends FlattenOneLevel<T> ? T : Flatten<FlattenOneLevel<T>>;
+type UsableEnv<R extends ContextObject = ContextObject, W extends ContextObject = ContextObject> = {
+    readable: R;
+    writable: W;
+};
+type ExtensionContentType = "paragraph" | "heading" | "blockquote" | "element" | "image" | "codeBlock" | "embed" | "bulletList" | "orderedList" | "taskList" | "horizontalRule" | "table" | "block";
+type UseEnv<C extends ExtensionBaseContext> = C[typeof __usableEnv] extends UsableEnv ? <K extends keyof Flatten<C[typeof __usableEnv]["readable"]> | keyof Flatten<C[typeof __usableEnv]["writable"]> | keyof C[typeof __usableEnv]["readable"] | keyof C[typeof __usableEnv]["writable"]>(key: K) => K extends keyof Flatten<C[typeof __usableEnv]["readable"]> ? Val<Flatten<C[typeof __usableEnv]["readable"]>[K]> : K extends keyof Flatten<C[typeof __usableEnv]["writable"]> ? [
+    MutableVal<Flatten<C[typeof __usableEnv]["writable"]>[K]>,
+    (value: Flatten<C[typeof __usableEnv]["writable"]>[K]) => void
+] : K extends keyof C[typeof __usableEnv]["readable"] ? Val<C[typeof __usableEnv]["readable"][K]> : K extends keyof C[typeof __usableEnv]["writable"] ? [
+    MutableVal<C[typeof __usableEnv]["writable"][K]>,
+    (value: C[typeof __usableEnv]["writable"][K]) => void
+] : never : never;
+interface ExtensionBaseContext<C extends ContextObject = ContextObject> {
+    client: Omit<Client, "reconfigure">;
+    token: string;
+    extensionId: string;
+    config?: C;
+    spec: ExtensionSpec;
+    [__usableEnv]: UsableEnv<any, any>;
+    use: UseEnv<this>;
+    flush(): Promise<void>;
+    notify(message: {
+        text: string;
+        type: "success" | "error";
+    }): Promise<void>;
+}
+interface ExtensionBaseViewContext<C extends ContextObject = ContextObject> extends ExtensionBaseContext<C> {
+    css(strings: TemplateStringsArray, ...values: Array<ContextValue>): string;
+}
+interface ExtensionConfigurationViewContext<C extends ContextObject = ContextObject> extends ExtensionBaseViewContext<C> {
+    [__usableEnv]: UsableEnv<{
+        [__value]: any;
+    }, {
+        config: C;
+    }>;
+}
+interface ExtensionContentPieceViewContext<C extends ContextObject = ContextObject, D extends ContextObject = ContextObject> extends ExtensionBaseViewContext<C> {
+    [__usableEnv]: UsableEnv<{
+        contentPiece: ContentPieceWithAdditionalData;
+    }, {
+        data: D;
+    }>;
+}
+interface ExtensionBlockActionViewContext<C extends ContextObject = ContextObject> extends ExtensionBaseViewContext<C> {
+    [__usableEnv]: UsableEnv<{
+        content: JSONContent;
+    }, {
+        [__value]: any;
+    }>;
+    replaceContent(contentHTML: string): Promise<void>;
+    refreshContent(): Promise<void>;
+}
+interface ExtensionElementViewContext<C extends ContextObject = ContextObject, P extends Record<string, any> = Record<string, any>> extends ExtensionBaseViewContext<C> {
+    [__usableEnv]: UsableEnv<{
+        [__value]: any;
+    }, {
+        props: P;
+    }>;
+}
+declare const __brand: unique symbol;
+declare const __props: unique symbol;
+declare const __mutable: unique symbol;
+declare const __usableEnv: unique symbol;
+declare const __value: unique symbol;
+declare const __id: unique symbol;
+declare const __componentName: unique symbol;
+type Brand<B> = {
+    [__brand]: B;
+};
+type Val<V extends ContextValue | {
+    [K: string]: Val;
+} = ContextValue | {
+    [K: string]: Val;
+}> = Brand<"Val"> & {
+    (): V;
+    [__value]: V;
+    [__id]: string;
+};
+type MutableVal<V extends ContextValue | {
+    [K: string]: MutableVal;
+} = ContextValue | {
+    [K: string]: MutableVal;
+}> = Val<V> & {
+    [__mutable]: true;
+};
+type Func<C extends ExtensionBaseContext | never = never> = Brand<"Func"> & {
+    (context: C): void | Promise<void>;
+    [__id]: string;
+};
+interface ExtensionEnvironment {
+    data: Record<string, Val>;
+    func: Record<string, Func<any>>;
+    views: Record<string, View<any>>;
+    effects: Array<{
+        [__id]: string;
+        dependencies: string[];
+        run: () => void;
+    }>;
+    currentScope: {
+        func: string[];
+        temp: string[];
+        effects: string[];
+        uid: string;
+    } | null;
+}
+interface ExtensionMetadata {
+    __value: typeof __value;
+    __id: typeof __id;
+    __componentName: typeof __componentName;
+    __usableEnv: typeof __usableEnv;
+}
+type View<C extends Partial<ExtensionBaseViewContext> | never = never> = Brand<"View"> & {
+    [__value]: (context: C) => ExtensionElement | Promise<ExtensionElement>;
+    [__id]: string;
+};
+interface ExtensionSpec {
+    name: string;
+    description: string;
+    displayName: string;
+    permissions: string[];
+    runtime: string;
+    icon: string;
+    iconDark?: string;
+}
+interface ExtensionBlockActionSpec {
+    id: string;
+    label: string;
+    blocks: string[];
+    view: string;
+}
+interface ExtensionPageSpec {
+    mainView?: string;
+    sidePanelView?: string;
+}
+interface ExtensionElementSpec {
+    type: string;
+    view: string;
+}
+interface ExtensionRuntimeSpec {
+    onUninstall?: string;
+    onConfigure?: string;
+    configurationView?: string;
+    contentPieceView?: string;
+    blockActions?: ExtensionBlockActionSpec[];
+    page?: ExtensionPageSpec;
+    elements?: ExtensionElementSpec[];
+}
+interface Extension {
+    getMetadata: () => ExtensionMetadata;
+    getEnvironment: () => ExtensionEnvironment;
+    triggerEffects: (...dependencies: string[]) => Promise<void>;
+    generateRuntimeSpec: () => ExtensionRuntimeSpec;
+    generateView: <C extends ExtensionBaseViewContext>(id: string, context: C, uid: string) => Promise<ExtensionElement>;
+    removeScope: (id: string) => void;
+    runFunction: <C extends ExtensionBaseContext | never = never>(id: string, context: C, uid: string) => Promise<void>;
+}
+type BaseProps<P extends Record<string, any>> = {
+    [K in keyof P as Exclude<K, symbol>]?: P[K];
+};
+type BindableProps<P extends Record<string, any>, M extends string | never = never> = {
+    [K in keyof P as `bind:${Exclude<Exclude<K, symbol>, M>}`]?: Val<P[K]>;
+} & {
+    [K in keyof P as `bind:${Extract<Exclude<K, symbol>, M>}`]?: MutableVal<P[K]>;
+};
+type EventProps<E extends string | never> = {
+    [K in E as `on:${Exclude<K, symbol>}`]?: Func;
+};
+interface ExtensionBaseComponent<P extends Record<string, any> = Record<string, any>, E extends string | never = never, M extends string | never = never> {
+    (props: BaseProps<P> & BindableProps<P, M> & EventProps<E>): void;
+    [__componentName]: string;
+    [__props]: P;
+}
+interface ExtensionBaseComponents {
+    Content: ExtensionBaseComponent<{
+        allowed?: ExtensionContentType[];
+        initial?: string;
+        class?: string;
+        wrapperClass?: string;
+    }>;
+    Element: ExtensionBaseComponent<{
+        type: string;
+    }>;
+    View: ExtensionBaseComponent<{
+        class: string;
+    }>;
+    SidePanelHeader: ExtensionBaseComponent<{
+        defaultSection: string;
+        section: string;
+        sections: Array<{
+            label: string;
+            icon?: string;
+            id: string;
+            action?: ExtensionElement;
+        }>;
+    }, "back">;
+    SidePanelContent: ExtensionBaseComponent<{}>;
+    Field: ExtensionBaseComponent<{
+        type: string;
+        color: "base" | "contrast";
+        label: string;
+        textarea: boolean;
+        value?: string | boolean;
+        disabled: boolean;
+        placeholder: string;
+        optional: boolean;
+        options?: Array<{
+            label: string;
+            value: string;
+        }>;
+    }, "change", "value">;
+    Select: ExtensionBaseComponent<{
+        options: Array<{
+            label: string;
+            value: string;
+        }>;
+        value?: string;
+        class?: string;
+        placeholder?: string;
+        color?: "base" | "contrast";
+        wrapperClass?: string;
+    }, "change", "value">;
+    Tooltip: ExtensionBaseComponent<{
+        text: string;
+        class: string;
+        fixed: boolean;
+        side?: "top" | "bottom" | "left" | "right";
+    }>;
+    Button: ExtensionBaseComponent<{
+        color: "base" | "contrast" | "primary" | "danger" | "success";
+        text: "base" | "contrast" | "primary" | "soft" | "danger" | "success";
+        class: string;
+        loading: boolean;
+        disabled: boolean;
+        hover: boolean;
+        badge: boolean;
+        variant: "text" | "solid";
+        size: "small" | "medium" | "large";
+        target: string;
+        link: string;
+    }, "click">;
+    Card: ExtensionBaseComponent<{
+        color: "base" | "contrast" | "primary";
+        class: string;
+    }>;
+    Icon: ExtensionBaseComponent<{
+        path: string;
+        class: string;
+    }>;
+    IconButton: ExtensionBaseComponent<{
+        color: "base" | "contrast" | "primary";
+        text: "base" | "contrast" | "primary" | "soft";
+        path: string;
+        class: string;
+        loading: boolean;
+        disabled: boolean;
+    }, "click">;
+    CollapsibleSection: ExtensionBaseComponent<{
+        icon: string;
+        label: string;
+        action?: ExtensionElement;
+        color?: "base" | "primary";
+        defaultOpened?: boolean;
+    }>;
+    Switch: ExtensionBaseComponent<{}>;
+    Match: ExtensionBaseComponent<{
+        when?: ContextValue;
+    }>;
+    Show: ExtensionBaseComponent<{
+        when: ContextValue;
+    }>;
+    Text: ExtensionBaseComponent<{
+        content: ContextValue;
+    }>;
+}
+type ExtensionElement = {
+    slot: Array<ExtensionElement | string>;
+    component: string;
+    props?: Record<string, string | boolean | number>;
+};
+interface ExtensionRuntimeConfig<C extends ContextObject = ContextObject> {
+    onUninstall?: Func<ExtensionBaseContext<C>>;
+    onConfigure?: Func<ExtensionBaseContext<C>>;
+    configurationView?: View<ExtensionConfigurationViewContext<C>>;
+    contentPieceView?: View<ExtensionContentPieceViewContext<C>>;
+    blockActions?: Array<Omit<ExtensionBlockActionSpec, "view"> & {
+        view: View<ExtensionBlockActionViewContext<C>>;
+    }>;
+    elements?: Array<Omit<ExtensionElementSpec, "view"> & {
+        view: View<ExtensionElementViewContext<C, any>>;
+    }>;
+    page?: {
+        mainView?: View<ExtensionBaseViewContext<C>>;
+        sidePanelView?: View<ExtensionBaseViewContext<C>>;
+    };
+}
+declare const generateId: () => string;
+declare const isVal: <T extends ContextValue>(value: T | Val<T>) => value is Val<T>;
+declare const Components: ExtensionBaseComponents;
+declare function createTemp<T extends ContextValue>(initialValue: T): [MutableVal<T>, (value: T) => void];
+declare function createTemp<T extends ContextValue>(initialValue?: T): [MutableVal<T | undefined>, (value: T | undefined) => void];
+declare function effect<D extends Val[]>(run: () => void, dependencies: D, options?: {
+    initial?: boolean;
+}): void;
+declare const computed: (<O extends ContextValue>(compute: () => O, dependencies: Val[]) => Val<O>) & {
+    eq: (...values: Array<Val<ContextValue> | ContextValue>) => Val<boolean>;
+    neq: (...values: Array<Val<ContextValue> | ContextValue>) => Val<boolean>;
+    gt: (a: number | Val<number>, b: number | Val<number>) => Val<boolean>;
+    lt: (a: number | Val<number>, b: number | Val<number>) => Val<boolean>;
+    and: (...values: Array<Val<ContextValue> | ContextValue>) => Val<boolean>;
+    or: (...values: Array<Val<ContextValue> | ContextValue>) => Val<boolean>;
+    not: (value: Val<ContextValue> | ContextValue) => Val<boolean>;
+    add: (...values: Array<Val<number> | number>) => Val<number>;
+    join: (...values: Array<Val<string> | string>) => Val<string>;
+    sub: (...values: Val<number>[]) => Val<number>;
+    mul: (...values: Val<number>[]) => Val<number>;
+    div: (a: number | Val<number>, b: number | Val<number>) => Val<number>;
+    mod: (a: number | Val<number>, b: number | Val<number>) => Val<number>;
+    neg: (value: number | Val<number>) => Val<number>;
+    when: <T extends ContextValue, F extends ContextValue = undefined>(condition: ContextValue | Val<ContextValue>, ifTrue: T | Val<T>, ifFalse?: F | Val<F>) => F extends undefined ? Val<T | null> : Val<T>;
+};
+declare const createFunction: <C extends ExtensionBaseContext | never = never>(run: (context: C) => void) => Func<C>;
+declare const createElement: <C extends ExtensionBaseComponent<any>>(component: C, props: C[typeof __props], ...children: Array<ExtensionElement | string>) => ExtensionElement;
+declare const createFragment: (...children: Array<ExtensionElement | string>) => ExtensionElement;
+declare const createView: <C extends ExtensionBaseViewContext>(run: (context: C) => ExtensionElement) => View<C>;
+declare const createRuntime: <C extends ContextObject = ContextObject>(runtimeConfig: ExtensionRuntimeConfig<C>) => Extension;
+
+export { type Brand, Components, type ContextObject, type ContextValue, type Extension, type ExtensionBaseComponents, type ExtensionBaseContext, type ExtensionBaseViewContext, type ExtensionBlockActionSpec, type ExtensionBlockActionViewContext, type ExtensionConfigurationViewContext, type ExtensionContentPieceViewContext, type ExtensionContentType, type ExtensionElement, type ExtensionElementSpec, type ExtensionElementViewContext, type ExtensionEnvironment, type ExtensionMetadata, type ExtensionRuntimeSpec, type ExtensionSpec, type Func, type MutableVal, type Val, type View, computed, createElement, createFragment, createFunction, createRuntime, createTemp, createView, effect, generateId, isVal };

package/dist/extensions.mjs

@@ -0,0 +1 @@
+const b=Symbol("usableEnv"),s=Symbol("value"),i=Symbol("id"),l=Symbol("componentName"),o={data:{},func:{},views:{},effects:[],currentScope:null},d=async(...e)=>{await Promise.all(o.effects.filter(t=>t.dependencies.some(n=>e.includes(n))).map(t=>t.run()))},m={},f=()=>`_${Math.random().toString(36).substring(2,9)}`,r=e=>e&&(typeof e=="object"||typeof e=="function")&&i in e&&s in e,y=new Proxy({},{get(e,t){const n=()=>{};return Object.defineProperty(n,l,{value:t}),n}});function w(e){if(!o.data.temp){const a=()=>o.data.temp[s];Object.defineProperty(a,i,{value:"temp"}),Object.defineProperty(a,s,{value:{},writable:!0}),o.data.temp=a}const t=f(),n=a=>{const p=o.data.temp;p[s][t]&&(p[s][t][s]=a),d(`temp.${t}`)},c=()=>o.data.temp[s][t][s];return Object.defineProperty(c,i,{value:`temp.${t}`}),Object.defineProperty(c,s,{value:e,writable:!0}),o.data.temp[s][t]=c,o.currentScope&&o.currentScope.temp.push(t),[c,n]}function g(e,t,n){const c=f();o.effects.push({[i]:c,dependencies:t.map(a=>a[i]),run:e}),o.currentScope&&o.currentScope.effects.push(c),n?.initial&&e()}const u=Object.assign(function(e,t){const[n,c]=w(e());return g(()=>{c(e())},t,{initial:!0}),n},{eq:(...e)=>{const t=e.filter(r);return u(()=>e.every(n=>(r(n)?n():n)===(r(e[0])?e[0]():e[0])),t)},neq:(...e)=>{const t=e.filter(r);return u(()=>e.some(n=>(r(n)?n():n)!==(r(e[0])?e[0]():e[0])),t)},gt:(e,t)=>{const n=[...r(e)?[e]:[],...r(t)?[t]:[]];return u(()=>(r(e)?e():e)>(r(t)?t():t),n)},lt:(e,t)=>{const n=[...r(e)?[e]:[],...r(t)?[t]:[]];return u(()=>(r(e)?e():e)<(r(t)?t():t),n)},and:(...e)=>{const t=e.filter(r);return u(()=>e.every(n=>r(n)?n():n),t)},or:(...e)=>{const t=e.filter(r);return u(()=>e.some(n=>r(n)?n():n),t)},not:e=>u(()=>!(r(e)?e():e),r(e)?[e]:[]),add:(...e)=>{const t=e.filter(r);return u(()=>e.reduce((n,c)=>n+(r(c)?c():c),0),t)},join:(...e)=>{const t=e.filter(r);return u(()=>e.reduce((n,c)=>n+(r(c)?c():c),""),t)},sub:(...e)=>{const t=e.filter(r);return u(()=>e.reduce((n,c)=>n-c(),0),t)},mul:(...e)=>{const t=e.filter(r);return u(()=>e.reduce((n,c)=>n*c(),1),t)},div:(e,t)=>{const n=[...r(e)?[e]:[],...r(t)?[t]:[]];return u(()=>(r(e)?e():e)/(r(t)?t():t),n)},mod:(e,t)=>{const n=[...r(e)?[e]:[],...r(t)?[t]:[]];return u(()=>(r(e)?e():e)%(r(t)?t():t),n)},neg:e=>u(()=>-(r(e)?e():e),r(e)?[e]:[]),when:(e,t,n)=>{const c=r(e)?[e]:[],a=r(t)?[t]:[],p=r(n)?[n]:[];return u(()=>(r(e)?e():e)?r(t)?t():t:n?r(n)?n():n:null,[...c,...a,...p])}}),S=e=>{const t=f(),n=e;return Object.defineProperty(n,i,{value:t}),o.func[t]=n,o.currentScope&&o.currentScope.func.push(t),n},P=(e,t,...n)=>({component:e[l]||"Fragment",slot:n,props:Object.fromEntries(Object.keys(t||{}).map(c=>{const a=t[c];return a&&a[i]?[c,a[i]]:[c,a]}))}),V=(...e)=>({component:"Fragment",slot:e,props:{}}),j=e=>{const t=f(),n={[i]:t,[s]:e};return o.views[t]=n,n},v=e=>{const t=m[e];t&&(t.func.forEach(n=>{delete o.func[n]}),t.temp.forEach(n=>{const c=o.data.temp;c()&&delete c()[n]}),t.effects.forEach(n=>{o.effects=o.effects.filter(c=>c[i]!==n)}))},E=e=>({getEnvironment:()=>o,getMetadata:()=>({__value:s,__id:i,__componentName:l,__usableEnv:b}),triggerEffects:d,generateRuntimeSpec:()=>({...e,onUninstall:e.onUninstall?.[i],onConfigure:e.onConfigure?.[i],configurationView:e.configurationView?.[i],contentPieceView:e.contentPieceView?.[i],blockActions:e.blockActions?.map(t=>({...t,view:t.view[i]})),elements:e.elements?.map(t=>({...t,view:t.view[i]})),page:e.page&&{mainView:e.page.mainView?.[i],sidePanelView:e.page.sidePanelView?.[i]}||void 0}),generateView:async(t,n,c)=>{const a=o.views[t]?.[s];if(a){o.currentScope={func:[],temp:[],effects:[],uid:c};const p=await a(n);return m[`view:${c}`]=o.currentScope,o.currentScope=null,p}return{component:"",slot:[]}},runFunction:async(t,n,c)=>{const a=o.func[t];a&&(o.currentScope={func:[],temp:[],effects:[],uid:c},await a(n),m[`func:${c}`]=o.currentScope,o.currentScope=null,v(`func:${c}`))},removeScope:v});export{y as Components,u as computed,P as createElement,V as createFragment,S as createFunction,E as createRuntime,w as createTemp,j as createView,g as effect,f as generateId,r as isVal};