2025/10/30-やったことリスト

export type AnUnsavedBuffer = {
    notebookName        : string,
    notebookUUID        : string,
    pageID              : string,
    pageUUID            : string,
    pageType            : string,
    UUID                : string, // to identify each buffers.
    timestamp           : Date,
    bufferContentString : string,
}

// NOTE: normally single page will add single buffer and update constantly if there are any modification.
export type unsavedBuffers = {
    buffers             : AnUnsavedBuffer[],
    addBuffer           : (unsavedBuffer:AnUnsavedBuffer) => void,
    removeBuffer        : (unsavedBuffer:AnUnsavedBuffer) => void,
    updateBuffer        : (unsavedBuffer:AnUnsavedBuffer) => void,      // not to create buffer, to update exist buffer
    getBuffers          : (pageID:string,pageUUID:string,notebookName:string) => AnUnsavedBuffer[],
    getUnsavedPageList  : () => string[],                               // for selector compornent.
}

export const useUnsavedBuffersStore = create<unsavedBuffers>((set,get) => ({
    buffers: [],
    addBuffer: (unsavedBuffer:AnUnsavedBuffer) => {
        const oldBuffer = get().buffers
        const newBuffer = []
        for(const aBuffer of oldBuffer){
            // when the buffer has already existed, abort the update
            if(aBuffer.UUID == unsavedBuffer.UUID) return
            newBuffer.push(aBuffer) 
        }
        newBuffer.push(unsavedBuffer)
        set({buffers:newBuffer})    
    },
    removeBuffer: (unsavedBuffer:AnUnsavedBuffer) => {
        const oldBuffer = get().buffers
        const newBuffer = []
        for(const aBuffer of oldBuffer){
            if(aBuffer.pageUUID == unsavedBuffer.pageUUID) continue
            newBuffer.push(aBuffer) 
        }
        set({buffers:newBuffer}) 
    },
    getBuffers: (pageID:string,pageUUID:string,notebookName:string) => {
        const allBuffer = get().buffers
        const buffers = []
        for(const aBuffer of allBuffer){
            if(
                aBuffer.pageID == pageID && 
                aBuffer.pageUUID == pageUUID &&
                aBuffer.notebookName == notebookName 
            ) 
                buffers.push(aBuffer) 
        }
        return buffers
    },
    updateBuffer: (unsavedBuffer:AnUnsavedBuffer) => {
        const oldBuffer = get().buffers
        const newBuffer = []
        for(const aBuffer of oldBuffer){
            // update
            if(aBuffer.UUID == unsavedBuffer.UUID) {
                // make sure the timestamp is the time of the last modify.
                unsavedBuffer.timestamp = new Date()
                newBuffer.push(unsavedBuffer)
                continue
            }
            newBuffer.push(aBuffer) 
        }
        set({buffers:newBuffer})    
    },
    getUnsavedPageList: () => {
        const buffers = get().buffers
        const bufferList:AnUnsavedBuffer[] = []

        for(const aBuffer of buffers){
            let find = false
            for(const AnBuffer of bufferList){
                if(AnBuffer.pageID == aBuffer.pageID){
                    find = true
                    break
                }
            }
            if(find) continue
            bufferList.push(aBuffer)
        }
        
        return bufferList
    }
})) 

{
    "responseType"  : "commandResponse",
    "status": "ok",
    "errorMessage": "nothing",
    "UUID":"UUID string",
    "command": "deletePage",
    "data":{ }
}

{
    "responseType"  : "interrupt",
    "event" : "updatePage",
    "UUID"  : "UUID string",
    "data"  : { }
}

    # check the extention
    if(pageType == "markdown" and not "md" in pageID):
        await errorResponse(
            websocket,
            request,
            "The page type mismatch.",
            [notebookName,pageID,pageType,pagePath]
            )
        return
    elif(not pageType == "markdown" and not "json" in pageID):
        await errorResponse(
            websocket,
            request,
            "The page type mismatch.",
            [notebookName,pageID,pageType,pagePath]
            )
        return

    # check the page UUID is match to the new data
    try:
        with open(pagePath,"rt",encoding="utf-8") as oldData:
            if(pageType == "markdown"):
                datastring = oldData.read()
                splitResult1 = datastring.split("++++")
                if(len(splitResult1) < 3):
                    await errorResponse(
                        websocket,
                        request,
                        "The old data string is malformed. Unable to find the metadata.",
                        [notebookName,pageID,pageType,pagePath,splitResult1,updateDataString]
                        )
                    return
                OLDpageMetadataJSON = json.loads(splitResult1[1])
                if(OLDpageMetadataJSON["UUID"] != pageMetadataJSON["UUID"]):
                    await errorResponse(
                        websocket,
                        request,
                        "The page UUID does not match to the old one.",
                        [notebookName,pageID,pageType,pagePath,pageMetadataJSON,OLDpageMetadataJSON],
                        error
                        )
                    return
            else:
                oldData = json.loads(oldData.read())
                if(oldData["UUID"] != pageMetadataJSON["UUID"]):
                    await errorResponse(
                        websocket,
                        request,
                        "The page UUID does not match to the old one.",
                        [notebookName,pageID,pageType,pagePath,pageMetadataJSON,oldData],
                        error
                        )
                    return
    except Exception as error:
        await errorResponse(
            websocket,
            request,
            "Failed to compare page UUID string.",
            [notebookName,pageID,pageType,pagePath,pageMetadataJSON,updateDataString],
            error
            )
        return

export type aProperty = {
    name        : string,
    UUID        : string,
    itemType    : string,
    settingItems: (({ name,settingElementWithCallbackForSave }:{ name:string,settingElementWithCallbackForSave:React.JSX.Element[] }) => JSX.Element)[]
    settingUI   : ({ name, items }: { name: string; items: React.JSX.Element[];}) => JSX.Element
}

export type properties = { 
    properties      : aProperty[],
    addProperty     : (property:aProperty) => void,
    removeProperty  : (property:aProperty) => void,
    getProperties   : (itemType:string) => aProperty[],
    cleanProperty   : () => void
}

export const useFreePagePropertiesStore = create<properties>((set,get) => ({
    properties: [],
    addProperty: (property:aProperty) => {
        const oldProperties = get().properties
        const newProperties = []
        for(const anProperty of oldProperties){
            if(anProperty.UUID == property.UUID) return
            newProperties.push(anProperty)
        }
        newProperties.push(property)
        set({properties:newProperties})
    },
    removeProperty: (property:aProperty) => {
        const oldProperties = get().properties
        const newProperties = []
        for(const anProperty of oldProperties){
            if(anProperty.UUID == property.UUID) continue
            newProperties.push(anProperty)
        }
        set({properties:newProperties})
    },
    getProperties   : (itemType:string) => {
        const targets = []
        const properties = get().properties
        for(const property of properties){
            if(property.itemType == itemType){
                targets.push(property)
            }
        }
        return targets
    },
    cleanProperty: () => {
        set({properties:[]})
    }
}))

// const test:aProperty = {
//     name:"test",
//     UUID:"test",
//     settingUI: Aproperty
// }

// <div className="aProperty">
//     <div className="name">Format</div>
//     <div className="items">
//         <div className="anItem">
//             <div className="itemName ml-auto">FontSize</div>
//             <input type="range" id="fontsize" min={10} max={100}></input>
//         </div>
//         <div className="anItem"></div>
//     </div>
// </div>

// This can be nested.
// items arg has to be AnItemForAproperty element array
export function Aproperty({ name,items }:{ name:string,items:React.JSX.Element[] }){
    return <div className="aProperty">
        <div className="name">{name}</div>
        <div className="items">{items}</div>
    </div>
}

// This have to be inside of Aproperty element
export function AnItemForAproperty({ name,settingElementWithCallbackForSave }:{ name:string,settingElementWithCallbackForSave:React.JSX.Element[] }){
    return <div className="anItem">
        <div className="itemName ml-auto">{name}</div>
        <div className="settingElement">{settingElementWithCallbackForSave}</div>
    </div>
}