@erudit-js/prose 4.1.0 → 4.2.0-dev.1

package/dist/app/appElement.d.ts

@@ -1,19 +1,20 @@
-import type { AnySchema, ProseElement } from '@jsprose/core';
 import { type ElementIcon, type ElementIconRaw } from './icon.js';
 import { type ElementComponent, type ElementComponentRaw } from './component.js';
 import { type ElementLanguages, type ElementLanguagesRaw, type ElementPhrases } from './language/element.js';
-export interface AppElementDefinition<TSchema extends AnySchema> {
+import type { Schema, ToProseElement } from 'tsprose';
+export interface ProseAppElementDefinition<TSchema extends Schema> {
     schema: TSchema;
     component: ElementComponentRaw;
     languages?: ElementLanguagesRaw<ElementPhrases>;
     icon?: ElementIconRaw;
-    createStorage?: (proseElement: ProseElement<TSchema>) => Promise<TSchema['Storage']> | TSchema['Storage'];
+    createStorage?: (proseElement: ToProseElement<TSchema>) => Promise<TSchema['Storage']> | TSchema['Storage'];
 }
-export interface AppElement<TSchema extends AnySchema = AnySchema> {
+export interface ProseAppElement<TSchema extends Schema = Schema> {
     schema: TSchema;
     component: ElementComponent;
     languages: ElementLanguages<ElementPhrases>;
     icon: ElementIcon;
-    createStorage?: (proseElement: ProseElement<TSchema>) => Promise<any> | any;
+    createStorage?: (proseElement: ToProseElement<TSchema>) => Promise<any> | any;
 }
-export declare function defineEruditProseAppElement<TSchema extends AnySchema>(appElement: AppElementDefinition<TSchema>): AppElement<TSchema>;
+export type ProseAppElements = Record<string, ProseAppElement>;
+export declare function defineProseAppElement<TSchema extends Schema>(appElement: ProseAppElementDefinition<TSchema>): ProseAppElement<TSchema>;

package/dist/app/appElement.js

@@ -1,7 +1,7 @@
 import { resolveElementIcon } from "./icon.js";
 import { resolveElementComponent } from "./component.js";
 import { resolveElementLanguages } from "./language/element.js";
-export function defineEruditProseAppElement(appElement) {
+export function defineProseAppElement(appElement) {
 	return {
 		schema: appElement.schema,
 		component: resolveElementComponent(appElement.component),

package/dist/app/composables/anchor.d.ts

@@ -1,16 +1,16 @@
 import { type InjectionKey, type Ref } from 'vue';
-import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { Schema, ToProseElement } from 'tsprose';
 export interface AnchorState {
     anchorResolving: Ref<boolean>;
     allowJumpToAnchor: Ref<boolean>;
-    anchorElement: Ref<ProseElement<AnySchema> | undefined>;
-    containsAnchorElements: Ref<Set<ProseElement<AnySchema>>>;
+    anchorElement: Ref<ToProseElement<Schema> | undefined>;
+    containsAnchorElements: Ref<Set<ToProseElement<Schema>>>;
 }
-export declare function useAnchorState(hashId: Ref<string | undefined>, element: ProseElement<AnySchema>): AnchorState;
+export declare function useAnchorState(hashId: Ref<string | undefined>, element: ToProseElement<Schema>): AnchorState;
 export declare const anchorStateSymbol: InjectionKey<AnchorState>;
-export declare function useIsAnchor(element: ProseElement<AnySchema>): import("vue").ComputedRef<boolean | undefined>;
-export declare function useContainsAnchor(element: ProseElement<AnySchema>): import("vue").ComputedRef<boolean>;
-export declare function useArrayContainsAnchor(elements: ProseElement<AnySchema>[]): import("vue").ComputedRef<number | undefined>;
+export declare function useIsAnchor(element: ToProseElement<Schema>): import("vue").ComputedRef<boolean | undefined>;
+export declare function useContainsAnchor(element: ToProseElement<Schema>): import("vue").ComputedRef<boolean>;
+export declare function useArrayContainsAnchor(elements: ToProseElement<Schema>[]): import("vue").ComputedRef<number | undefined>;
 export declare function useAnchorResolving(): Ref<boolean, boolean>;
 export declare function useJumpToAnchor(): (element: HTMLElement) => void;
 export declare function useResolveAnchor(): () => void;

package/dist/app/composables/appElement.d.ts

@@ -1,4 +1,4 @@
-import { type AnySchema, type ProseElement } from '@jsprose/core';
-import type { AppElement } from '../appElement.js';
-export declare function useAppElement(schemaName: string): AppElement;
-export declare function useAppElement(element: ProseElement<AnySchema>): AppElement;
+import type { Schema, ToProseElement } from 'tsprose';
+import type { ProseAppElement } from '../appElement.js';
+export declare function useAppElement(schemaName: string): ProseAppElement;
+export declare function useAppElement(element: ToProseElement<Schema>): ProseAppElement;

package/dist/app/composables/appElement.js

@@ -1,16 +1,16 @@
-import { ProseError } from "@jsprose/core";
 import { useProseContext } from "./context.js";
+import { EruditProseError } from "../../error.js";
 export function useAppElement(elementOrName) {
 	let schemaName;
 	if (typeof elementOrName === "string") {
 		schemaName = elementOrName;
 	} else {
-		schemaName = elementOrName.schemaName;
+		schemaName = elementOrName.schema.name;
 	}
 	const { appElements } = useProseContext();
 	const appElement = appElements[schemaName];
 	if (!appElement) {
-		throw new ProseError(`No AppElement found for schema "${schemaName}"!`);
+		throw new EruditProseError(`No AppElement found for schema "${schemaName}"!`);
 	}
 	return appElement;
 }

package/dist/app/composables/context.d.ts

@@ -3,11 +3,12 @@ import type { useFloating, UseFloatingOptions } from '@floating-ui/vue';
 import type { EruditLanguageCode } from '@erudit-js/core/eruditConfig/language';
 import type { EruditMode } from '@erudit-js/core/mode';
 import type { FormatText } from '@erudit-js/core/formatText';
-import type { AppElement } from '../appElement.js';
+import type { ProseAppElement } from '../appElement.js';
 export interface ProseContext {
     mode: EruditMode;
+    setHtmlIds: boolean;
     languageCode: EruditLanguageCode;
-    appElements: Record<string, AppElement>;
+    appElements: Record<string, ProseAppElement>;
     formatText: FormatText;
     pathUrl: string;
     baseUrl: string;

package/dist/app/composables/elementIcon.d.ts

@@ -1,3 +1,3 @@
-import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { ToProseElement, Schema } from 'tsprose';
 export declare function useElementIcon(schemaName: string): Promise<string>;
-export declare function useElementIcon(element: ProseElement<AnySchema>): Promise<string>;
+export declare function useElementIcon(element: ToProseElement<Schema>): Promise<string>;

package/dist/app/composables/elementIcon.js

@@ -1,5 +1,5 @@
 import { useAppElement } from "./appElement.js";
 export async function useElementIcon(elementOrName) {
-	const appElement = useAppElement(typeof elementOrName === "string" ? elementOrName : elementOrName.schemaName);
+	const appElement = useAppElement(typeof elementOrName === "string" ? elementOrName : elementOrName.schema.name);
 	return appElement.icon();
 }

package/dist/app/composables/language.d.ts

@@ -1,8 +1,8 @@
-import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { ProseElement } from 'tsprose';
 import type { ElementPhrases } from '../language/element.js';
 export declare function useProseLanguage(): Promise<{
     copy_link: string;
     copied: string;
 }>;
 export declare function useElementPhrase<TPhrases extends ElementPhrases>(schemaName: string): Promise<TPhrases>;
-export declare function useElementPhrase<TPhrases extends ElementPhrases>(element: ProseElement<AnySchema>): Promise<TPhrases>;
+export declare function useElementPhrase<TPhrases extends ElementPhrases>(element: ProseElement): Promise<TPhrases>;

package/dist/app/composables/language.js

@@ -7,7 +7,7 @@ export async function useProseLanguage() {
 }
 export async function useElementPhrase(elementOrName) {
 	const { languageCode } = useProseContext();
-	const appElement = useAppElement(typeof elementOrName === "string" ? elementOrName : elementOrName.schemaName);
+	const appElement = useAppElement(typeof elementOrName === "string" ? elementOrName : elementOrName.schema.name);
 	const languages = appElement.languages;
 	return await languages[languageCode]();
 }

package/dist/app/composables/storage.d.ts

@@ -1,5 +1,5 @@
 import { type InjectionKey } from 'vue';
-import { type AnySchema, type GenericStorage, type ProseElement } from '@jsprose/core';
-export declare const proseStorageSymbol: InjectionKey<GenericStorage>;
-export declare function useProseStorage(): GenericStorage;
-export declare function useElementStorage<TSchema extends AnySchema>(element: ProseElement<TSchema>): Promise<TSchema['Storage']>;
+import type { ProseElement, ProseStorage } from 'tsprose';
+export declare const proseStorageSymbol: InjectionKey<ProseStorage>;
+export declare function useProseStorage(): ProseStorage;
+export declare function useElementStorage<TElement extends ProseElement>(element: TElement): Promise<TElement['schema']['Storage']>;

package/dist/app/composables/storage.js

@@ -1,5 +1,4 @@
 import { inject } from "vue";
-import { ProseError } from "@jsprose/core";
 import { useAppElement } from "./appElement.js";
 export const proseStorageSymbol = Symbol();
 export function useProseStorage() {
@@ -17,7 +16,4 @@ export async function useElementStorage(element) {
 	if (element.storageKey in storage) {
 		return storage[element.storageKey];
 	}
-	// throw new ProseError(
-	//     `Element ${element.schemaName} with storage key "${element.storageKey}" has no storage value!`,
-	// );
 }

package/dist/app/default/Mix.vue

@@ -1,9 +1,9 @@
 <script lang="ts" setup>
-import { type mixSchema, type ProseElement } from '@jsprose/core';
+import type { MixSchema, ToProseElement } from 'tsprose';
 
 import Render from '../shared/Render.vue';
 
-const { element } = defineProps<{ element: ProseElement<typeof mixSchema> }>();
+const { element } = defineProps<{ element: ToProseElement<MixSchema> }>();
 </script>
 
 <template>

package/dist/app/default/Text.vue

@@ -1,13 +1,13 @@
 <script lang="ts" setup>
 import { Text, h } from 'vue';
-import type { ProseElement, textSchema } from '@jsprose/core';
+import type { TextSchema, ToProseElement } from 'tsprose';
 
 import {
   useFormatText,
   useFormatTextState,
 } from '../composables/formatText.js';
 
-const { element } = defineProps<{ element: ProseElement<typeof textSchema> }>();
+const { element } = defineProps<{ element: ToProseElement<TextSchema> }>();
 const formatTextState = useFormatTextState();
 const formatText = useFormatText();
 

package/dist/app/shared/Prose.vue

@@ -1,6 +1,6 @@
 <script lang="ts" setup>
 import { provide } from 'vue';
-import type { AnySchema, GenericStorage, ProseElement } from '@jsprose/core';
+import type { ProseElement, ProseStorage } from 'tsprose';
 import { createFormatTextState } from '@erudit-js/core/formatText';
 
 import {
@@ -13,8 +13,8 @@ import { anchorStateSymbol, useAnchorState } from '../composables/anchor.js';
 import { formatTextStateSymbol } from '../composables/formatText.js';
 
 const { element, storage, context } = defineProps<{
-  element: ProseElement<AnySchema>;
-  storage: GenericStorage;
+  element: ProseElement;
+  storage: ProseStorage;
   context: ProseContext;
 }>();
 

package/dist/app/shared/Render.vue

@@ -1,26 +1,17 @@
 <script lang="ts" setup>
 import { h, type Component } from 'vue';
-import {
-  inlinersSchema,
-  mixSchema,
-  textSchema,
-  type AnySchema,
-  type ProseElement,
-} from '@jsprose/core';
+import { mixSchema, textSchema, type ProseElement } from 'tsprose';
 
 import { useAppElement } from '../composables/appElement.js';
 import Mix from '../default/Mix.vue';
-import Inliners from '../default/Inliners.vue';
 import Text from '../default/Text.vue';
 
-const { element } = defineProps<{ element: ProseElement<AnySchema> }>();
+const { element } = defineProps<{ element: ProseElement }>();
 
 const ElementComponent: Component = await (async () => {
-  switch (element.schemaName) {
+  switch (element.schema.name) {
     case mixSchema.name:
       return Mix;
-    case inlinersSchema.name:
-      return Inliners;
     case textSchema.name:
       return Text;
   }
@@ -30,7 +21,7 @@ const ElementComponent: Component = await (async () => {
     return await appElement.component();
   } catch (error) {
     console.warn(
-      `[Prose] [Render] Missing component for element schema: ${element.schemaName}`,
+      `[Prose] [Render] Missing component for element schema: ${element.schema.name}`,
     );
 
     return {
@@ -38,7 +29,7 @@ const ElementComponent: Component = await (async () => {
         return h(
           'span',
           { class: 'text-red-500 font-semibold font-mono' },
-          `<${element.schemaName}/>`,
+          `<${element.schema.name}/>`,
         );
       },
     };

package/dist/app/shared/block/AsideMenu.vue

@@ -1,13 +1,13 @@
 <script setup lang="ts">
 import { computed } from 'vue';
-import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { ProseElement } from 'tsprose';
 
 import { useElementPhrase } from '../../composables/language.js';
 import AsideMenuSeparator from './AsideMenuSeparator.vue';
 import AsideMenuCopyLink from './AsideMenuCopyLink.vue';
 
 const { element } = defineProps<{
-  element: ProseElement<AnySchema>;
+  element: ProseElement;
 }>();
 
 const hasLink = computed(() => {

package/dist/app/shared/block/AsideMenuCopyLink.vue

@@ -19,7 +19,7 @@ let resetTimer: number | undefined;
 
 async function copyLink() {
   await navigator.clipboard.writeText(
-    location.origin + baseUrl + pathUrl.substring(1) + '#' + elementId,
+    location.origin + baseUrl + pathUrl.substring(1) + '?element=' + elementId,
   );
   copied.value = true;
   if (resetTimer) clearTimeout(resetTimer);

package/dist/app/shared/block/Block.vue

@@ -8,7 +8,6 @@ import {
   watchEffect,
 } from 'vue';
 import { useFloating, autoUpdate, offset, shift } from '@floating-ui/vue';
-import type { BlockSchema, ProseElement } from '@jsprose/core';
 
 import { useProseContext } from '../../composables/context.js';
 import { useElementIcon } from '../../composables/elementIcon.js';
@@ -19,9 +18,10 @@ import {
 } from '../../composables/anchor.js';
 import AsideMenu from './AsideMenu.vue';
 import { useFormatTextState } from '../../composables/formatText.js';
+import type { BlockProseElement } from 'tsprose';
 
-const { element } = defineProps<{ element: ProseElement<BlockSchema> }>();
-const { EruditIcon, EruditTransition } = useProseContext();
+const { element } = defineProps<{ element: BlockProseElement }>();
+const { EruditIcon, EruditTransition, setHtmlIds } = useProseContext();
 const elementIcon = await useElementIcon(element);
 
 const formatTextState = useFormatTextState();
@@ -173,7 +173,7 @@ onBeforeUnmount(() => {
 <template>
   <div
     ref="block"
-    :id="element.id"
+    :id="setHtmlIds ? element.id : undefined"
     :class="[$style.block, 'scroll-mt-big pr-(--proseAsideWidth)']"
   >
     <div :class="[$style.blockAbove, 'h-(--proseGap)']"></div>

package/dist/app/shared/inliner/Inliner.vue

@@ -1,7 +1,7 @@
 <script lang="ts" setup>
-import type { InlinerSchema, ProseElement } from '@jsprose/core';
+import type { InlinerProseElement } from 'tsprose';
 
-defineProps<{ element: ProseElement<InlinerSchema> }>();
+defineProps<{ element: InlinerProseElement }>();
 </script>
 
 <template>

package/dist/coreElement.d.ts

@@ -1,10 +1,28 @@
-import type { AnyRegistryItem } from '@jsprose/core';
-export interface EruditProseCoreElement {
-    registryItem: AnyRegistryItem;
-    dependencies?: Record<string, {
+import type { ElementStorageCreator, Schema } from 'tsprose';
+import type { RawToProseSchemaHook } from './rawToProse/hook.js';
+import type { EruditTag, ToEruditTag } from './tag.js';
+export interface ProseCoreElementDependencies {
+    [dependencyName: string]: {
         transpile?: boolean;
         optimize?: boolean;
-    }>;
+    };
 }
-export declare function defineEruditProseCoreElement<TElement extends EruditProseCoreElement>(coreElement: TElement): TElement;
-export declare function defineEruditProseCoreElements<TElements extends readonly EruditProseCoreElement[]>(...coreElements: [...TElements]): TElements;
+export type ToProseCoreElement<TSchema extends Schema, Tags extends EruditTag[] | undefined> = {
+    schema: TSchema;
+    tags: Tags;
+    dependencies?: ProseCoreElementDependencies;
+} & ({
+    createStorage: ElementStorageCreator<TSchema>;
+} | {
+    createStorage?: undefined;
+}) & ({
+    rawToProseHook: RawToProseSchemaHook<TSchema>;
+} | {
+    rawToProseHook?: undefined;
+});
+export type ProseCoreElement = ToProseCoreElement<Schema, EruditTag[] | undefined>;
+export type ProseCoreElements = Record<string, ProseCoreElement>;
+export declare function defineProseCoreElement<const TSchema extends Schema, const CoreElement extends ToProseCoreElement<TSchema, ToEruditTag<TSchema, string, any>[] | undefined>>(coreElement: CoreElement & {
+    schema: TSchema;
+}): CoreElement;
+export declare function defineProseCoreElements<const CoreElements extends ProseCoreElement[]>(...coreElements: CoreElements): CoreElements;

package/dist/coreElement.js

@@ -1,6 +1,6 @@
-export function defineEruditProseCoreElement(coreElement) {
+export function defineProseCoreElement(coreElement) {
 	return coreElement;
 }
-export function defineEruditProseCoreElements(...coreElements) {
+export function defineProseCoreElements(...coreElements) {
 	return coreElements;
 }

package/dist/elements/accent/Accent.vue

@@ -1,6 +1,6 @@
 <script lang="ts" setup>
 import { shallowRef } from 'vue';
-import { type ProseElement } from '@jsprose/core';
+import type { ToProseElement } from 'tsprose';
 
 import {
   isAccentMainElement,
@@ -19,7 +19,7 @@ import Render from '../../app/shared/Render.vue';
 import AccentColumnSection from './AccentColumnSection.vue';
 import AccentRowSections from './AccentRowSections.vue';
 
-const { element } = defineProps<{ element: ProseElement<AccentSchema> }>();
+const { element } = defineProps<{ element: ToProseElement<AccentSchema> }>();
 
 const { EruditIcon } = useProseContext();
 const formatText = useFormatText();
@@ -28,8 +28,8 @@ const accentIcon = await useElementIcon(element);
 const phrase =
   await useElementPhrase<ElementPhrases<Record<string, string>>>(element);
 
-const mainSection = shallowRef<ProseElement<AccentMainSchema>>();
-const sections = shallowRef<ProseElement<AccentSectionSchema>[]>([]);
+const mainSection = shallowRef<ToProseElement<AccentMainSchema>>();
+const sections = shallowRef<ToProseElement<AccentSectionSchema>[]>([]);
 
 for (const child of element.children) {
   if (isAccentMainElement(child)) {

package/dist/elements/accent/AccentColumnSection.vue

@@ -1,6 +1,6 @@
 <script lang="ts" setup>
 import { ref, watchEffect } from 'vue';
-import type { ProseElement } from '@jsprose/core';
+import type { ToProseElement } from 'tsprose';
 
 import type { AccentSectionSchema } from './core.js';
 import { useProseContext } from '../../app/composables/context.js';
@@ -10,7 +10,7 @@ import Render from '../../app/shared/Render.vue';
 
 const { section } = defineProps<{
   title: string;
-  section: ProseElement<AccentSectionSchema>;
+  section: ToProseElement<AccentSectionSchema>;
 }>();
 
 const { EruditIcon } = useProseContext();

package/dist/elements/accent/AccentRowSections.vue

@@ -1,6 +1,6 @@
 <script lang="ts" setup>
 import { ref, watchEffect } from 'vue';
-import type { ProseElement } from '@jsprose/core';
+import type { ToProseElement } from 'tsprose';
 
 import type { AccentSectionSchema } from './core.js';
 import { useArrayContainsAnchor } from '../../app/composables/anchor.js';
@@ -8,7 +8,7 @@ import Render from '../../app/shared/Render.vue';
 
 const { sections } = defineProps<{
   sectionTitles: string[];
-  sections: ProseElement<AccentSectionSchema>[];
+  sections: ToProseElement<AccentSectionSchema>[];
 }>();
 
 const openedSectionI = ref<number>();

package/dist/elements/accent/app.d.ts

@@ -1,4 +1,4 @@
-import { type AppElement, type AppElementDefinition } from '../../app/appElement.js';
+import { type ProseAppElement, type ProseAppElementDefinition } from '../../app/appElement.js';
 import type { ElementLanguagesRaw, ElementPhrases } from '../../app/language/element.js';
 import type { AccentSchema } from './core.js';
 export interface AccentAppOptions {
@@ -9,13 +9,13 @@ export interface AccentAppOptions {
     };
 }
 export declare function accentSectionNamePhrase<TSectionName extends string>(sectionName: TSectionName): `section_title_${TSectionName}`;
-export type AccentAppDefinition<TAccentSchema extends AccentSchema> = Omit<AppElementDefinition<TAccentSchema>, 'component' | 'createStorage'> & {
+export type AccentAppDefinition<TAccentSchema extends AccentSchema> = Omit<ProseAppElementDefinition<TAccentSchema>, 'component' | 'createStorage'> & {
     schema: TAccentSchema;
     accent: AccentAppOptions;
     languages: ElementLanguagesRaw<ElementPhrases<{
         [K in ReturnType<typeof accentSectionNamePhrase<TAccentSchema['SectionNames'][number]>>]: string;
     }>>;
 };
-export declare function defineAccentApp<TAccentSchema extends AccentSchema>(accentApp: AccentAppDefinition<TAccentSchema>): AppElement<TAccentSchema> & {
+export declare function defineAccentApp<TAccentSchema extends AccentSchema>(accentApp: AccentAppDefinition<TAccentSchema>): ProseAppElement<TAccentSchema> & {
     accent: AccentAppOptions;
 };

package/dist/elements/accent/app.js

@@ -1,9 +1,9 @@
-import { defineEruditProseAppElement } from "../../app/appElement.js";
+import { defineProseAppElement } from "../../app/appElement.js";
 export function accentSectionNamePhrase(sectionName) {
 	return `section_title_${sectionName}`;
 }
 export function defineAccentApp(accentApp) {
-	const appElement = defineEruditProseAppElement({
+	const appElement = defineProseAppElement({
 		schema: accentApp.schema,
 		component: () => import("./Accent.vue"),
 		icon: accentApp.icon,